softcore-rv64 0.6.0

#![allow(warnings)]

use softcore_prelude::*;

use crate::arch_prelude::*;

/// The software core.
/// 
/// This struct represents a software core, and holds all the registers as well as the core configuration.
/// The core is the main abstraction exposed by the softcore library and represents a single execution thread.
/// 
/// The raw functions translated directly from the specification are available in the `raw` module, whereas higher-level wrappers are implemented as methods on the [Core] struct directly.
#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Core {
    pub PC: xlenbits,
    pub nextPC: xlenbits,
    pub x1: regtype,
    pub x2: regtype,
    pub x3: regtype,
    pub x4: regtype,
    pub x5: regtype,
    pub x6: regtype,
    pub x7: regtype,
    pub x8: regtype,
    pub x9: regtype,
    pub x10: regtype,
    pub x11: regtype,
    pub x12: regtype,
    pub x13: regtype,
    pub x14: regtype,
    pub x15: regtype,
    pub x16: regtype,
    pub x17: regtype,
    pub x18: regtype,
    pub x19: regtype,
    pub x20: regtype,
    pub x21: regtype,
    pub x22: regtype,
    pub x23: regtype,
    pub x24: regtype,
    pub x25: regtype,
    pub x26: regtype,
    pub x27: regtype,
    pub x28: regtype,
    pub x29: regtype,
    pub x30: regtype,
    pub x31: regtype,
    pub cur_privilege: Privilege,
    pub cur_inst: xlenbits,
    pub misa: Misa,
    pub mstatus: Mstatus,
    pub menvcfg: MEnvcfg,
    pub senvcfg: SEnvcfg,
    pub mie: Minterrupts,
    pub mip: Minterrupts,
    pub medeleg: Medeleg,
    pub mideleg: Minterrupts,
    pub mtvec: Mtvec,
    pub mcause: Mcause,
    pub mepc: xlenbits,
    pub mtval: xlenbits,
    pub mscratch: xlenbits,
    pub scounteren: Counteren,
    pub mcounteren: Counteren,
    pub mcountinhibit: Counterin,
    pub mcycle: BitVector<64>,
    pub mtime: BitVector<64>,
    pub minstret: BitVector<64>,
    pub minstret_increment: bool,
    pub mvendorid: BitVector<32>,
    pub mimpid: xlenbits,
    pub marchid: xlenbits,
    pub mhartid: xlenbits,
    pub mconfigptr: xlenbits,
    pub stvec: Mtvec,
    pub sscratch: xlenbits,
    pub sepc: xlenbits,
    pub scause: Mcause,
    pub stval: xlenbits,
    pub tselect: xlenbits,
    pub vstart: BitVector<16>,
    pub vl: xlenbits,
    pub vtype: Vtype,
    pub pmpcfg_n: [Pmpcfg_ent; (64 as usize)],
    pub pmpaddr_n: [xlenbits; (64 as usize)],
    pub vr0: vregtype,
    pub vr1: vregtype,
    pub vr2: vregtype,
    pub vr3: vregtype,
    pub vr4: vregtype,
    pub vr5: vregtype,
    pub vr6: vregtype,
    pub vr7: vregtype,
    pub vr8: vregtype,
    pub vr9: vregtype,
    pub vr10: vregtype,
    pub vr11: vregtype,
    pub vr12: vregtype,
    pub vr13: vregtype,
    pub vr14: vregtype,
    pub vr15: vregtype,
    pub vr16: vregtype,
    pub vr17: vregtype,
    pub vr18: vregtype,
    pub vr19: vregtype,
    pub vr20: vregtype,
    pub vr21: vregtype,
    pub vr22: vregtype,
    pub vr23: vregtype,
    pub vr24: vregtype,
    pub vr25: vregtype,
    pub vr26: vregtype,
    pub vr27: vregtype,
    pub vr28: vregtype,
    pub vr29: vregtype,
    pub vr30: vregtype,
    pub vr31: vregtype,
    pub vcsr: Vcsr,
    pub mhpmevent: [HpmEvent; (32 as usize)],
    pub mhpmcounter: [BitVector<64>; (32 as usize)],
    pub float_result: BitVector<64>,
    pub float_fflags: BitVector<64>,
    pub f0: fregtype,
    pub f1: fregtype,
    pub f2: fregtype,
    pub f3: fregtype,
    pub f4: fregtype,
    pub f5: fregtype,
    pub f6: fregtype,
    pub f7: fregtype,
    pub f8: fregtype,
    pub f9: fregtype,
    pub f10: fregtype,
    pub f11: fregtype,
    pub f12: fregtype,
    pub f13: fregtype,
    pub f14: fregtype,
    pub f15: fregtype,
    pub f16: fregtype,
    pub f17: fregtype,
    pub f18: fregtype,
    pub f19: fregtype,
    pub f20: fregtype,
    pub f21: fregtype,
    pub f22: fregtype,
    pub f23: fregtype,
    pub f24: fregtype,
    pub f25: fregtype,
    pub f26: fregtype,
    pub f27: fregtype,
    pub f28: fregtype,
    pub f29: fregtype,
    pub f30: fregtype,
    pub f31: fregtype,
    pub fcsr: Fcsr,
    pub mcyclecfg: CountSmcntrpmf,
    pub minstretcfg: CountSmcntrpmf,
    pub mtimecmp: BitVector<64>,
    pub stimecmp: BitVector<64>,
    pub htif_tohost: BitVector<64>,
    pub htif_done: bool,
    pub htif_exit_code: BitVector<64>,
    pub htif_cmd_write: bool,
    pub htif_payload_writes: BitVector<4>,
    pub tlb: [Option<TLB_Entry>; (num_tlb_entries as usize)],
    pub satp: xlenbits,
    pub hart_state: HartState,
    pub config: Config,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Config {
    pub base: ConfigBase,
    pub extensions: ConfigExtensions,
    pub memory: ConfigMemory,
    pub platform: ConfigPlatform,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigBase {
    pub mtval_has_illegal_instruction_bits: bool,
    pub writable_fiom: bool,
    pub writable_hpm_counters: BitVector<32>,
    pub writable_misa: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigExtensions {
    pub A: ConfigA,
    pub B: ConfigB,
    pub FD: ConfigFD,
    pub M: ConfigM,
    pub S: ConfigS,
    pub Smcntrpmf: ConfigSmcntrpmf,
    pub Sscofpmf: ConfigSscofpmf,
    pub Sstc: ConfigSstc,
    pub Sv32: ConfigSv32,
    pub Sv39: ConfigSv39,
    pub Sv48: ConfigSv48,
    pub Sv57: ConfigSv57,
    pub Svbare: ConfigSvbare,
    pub Svinval: ConfigSvinval,
    pub U: ConfigU,
    pub V: ConfigV,
    pub Zaamo: ConfigZaamo,
    pub Zabha: ConfigZabha,
    pub Zalrsc: ConfigZalrsc,
    pub Zba: ConfigZba,
    pub Zbb: ConfigZbb,
    pub Zbc: ConfigZbc,
    pub Zbkb: ConfigZbkb,
    pub Zbkc: ConfigZbkc,
    pub Zbkx: ConfigZbkx,
    pub Zbs: ConfigZbs,
    pub Zca: ConfigZca,
    pub Zcb: ConfigZcb,
    pub Zcd: ConfigZcd,
    pub Zcf: ConfigZcf,
    pub Zcmop: ConfigZcmop,
    pub Zfa: ConfigZfa,
    pub Zfh: ConfigZfh,
    pub Zfhmin: ConfigZfhmin,
    pub Zfinx: ConfigZfinx,
    pub Zhinx: ConfigZhinx,
    pub Zicbom: ConfigZicbom,
    pub Zicboz: ConfigZicboz,
    pub Zicntr: ConfigZicntr,
    pub Zicond: ConfigZicond,
    pub Zifencei: ConfigZifencei,
    pub Zihpm: ConfigZihpm,
    pub Zimop: ConfigZimop,
    pub Zknd: ConfigZknd,
    pub Zkne: ConfigZkne,
    pub Zknh: ConfigZknh,
    pub Zkr: ConfigZkr,
    pub Zksed: ConfigZksed,
    pub Zksh: ConfigZksh,
    pub Zmmul: ConfigZmmul,
    pub Zvbb: ConfigZvbb,
    pub Zvbc: ConfigZvbc,
    pub Zvkb: ConfigZvkb,
    pub Zvknha: ConfigZvknha,
    pub Zvknhb: ConfigZvknhb,
    pub Zvksh: ConfigZvksh,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigA {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigB {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigFD {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigM {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigS {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSmcntrpmf {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSscofpmf {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSstc {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSv32 {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSv39 {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSv48 {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSv57 {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSvbare {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigSvinval {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigU {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigV {
    pub supported: bool,
    pub vlen_exp: i128,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZaamo {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZabha {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZalrsc {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZba {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbc {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbkb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbkc {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbkx {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZbs {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZca {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZcb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZcd {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZcf {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZcmop {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZfa {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZfh {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZfhmin {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZfinx {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZhinx {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZicbom {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZicboz {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZicntr {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZicond {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZifencei {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZihpm {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZimop {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZknd {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZkne {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZknh {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZkr {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZksed {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZksh {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZmmul {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvbb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvbc {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvkb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvknha {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvknhb {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigZvksh {
    pub supported: bool,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigMemory {
    pub pmp: ConfigPmp,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigPmp {
    pub count: i128,
    pub grain: i128,
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct ConfigPlatform {
    pub archid: i128,
    pub cache_block_size_exp: i128,
    pub hartid: i128,
    pub impid: i128,
    pub vendorid: i128,
}

/// Initialize all registers.
/// 
/// This function should be called before using a fresh core, otherwise the core might not be in a valid state.
pub fn _reset_all_registers(core_ctx: &mut Core) {
    core_ctx.misa = _reset_misa();
    core_ctx.mstatus = _reset_mstatus(core_ctx);
    core_ctx.menvcfg = _reset_menvcfg(core_ctx);
    core_ctx.senvcfg = _reset_senvcfg(core_ctx);
    core_ctx.mvendorid = _reset_mvendorid(core_ctx);
    core_ctx.mimpid = _reset_mimpid(core_ctx);
    core_ctx.marchid = _reset_marchid(core_ctx);
    core_ctx.mhartid = _reset_mhartid(core_ctx);
    core_ctx.mconfigptr = _reset_mconfigptr();
    core_ctx.tlb = _reset_tlb();
    core_ctx.hart_state = _reset_hart_state()
}

/// Initialize the misa register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L80-83.
pub fn _reset_misa() -> Misa {
    _update_Misa_MXL(Mk_Misa(zeros::<64>(64)), architecture_forwards(Architecture::RV64))
}

/// Initialize the mstatus register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L275-284.
pub fn _reset_mstatus(core_ctx: &mut Core) -> Mstatus {
    let mxl = architecture_forwards(Architecture::RV64);
    {
        let var_1 = {
            let var_3 = if {((64 != 32) && hartSupports(core_ctx, extension::Ext_S))} {
                mxl
            } else {
                zeros::<2>(2)
            };
            _update_Mstatus_SXL(Mk_Mstatus(zeros::<64>(64)), var_3)
        };
        let var_2 = if {((64 != 32) && hartSupports(core_ctx, extension::Ext_U))} {
            mxl
        } else {
            zeros::<2>(2)
        };
        _update_Mstatus_UXL(var_1, var_2)
    }
}

/// Initialize the menvcfg register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L371.
pub fn _reset_menvcfg(core_ctx: &mut Core) -> MEnvcfg {
    legalize_menvcfg(core_ctx, Mk_MEnvcfg(zeros::<64>(64)), zeros::<64>(64))
}

/// Initialize the senvcfg register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L372.
pub fn _reset_senvcfg(core_ctx: &mut Core) -> SEnvcfg {
    legalize_senvcfg(core_ctx, Mk_SEnvcfg(zeros::<64>(64)), zeros::<64>(64))
}

/// Initialize the mvendorid register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L652.
pub fn _reset_mvendorid(core_ctx: &mut Core) -> BitVector<32> {
    to_bits::<32>(32, (core_ctx.config.platform.vendorid as i128))
}

/// Initialize the mimpid register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L653.
pub fn _reset_mimpid(core_ctx: &mut Core) -> xlenbits {
    to_bits::<64>(64, (core_ctx.config.platform.impid as i128))
}

/// Initialize the marchid register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L654.
pub fn _reset_marchid(core_ctx: &mut Core) -> xlenbits {
    to_bits::<64>(64, (core_ctx.config.platform.archid as i128))
}

/// Initialize the mhartid register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L655.
pub fn _reset_mhartid(core_ctx: &mut Core) -> xlenbits {
    to_bits::<64>(64, (core_ctx.config.platform.hartid as i128))
}

/// Initialize the mconfigptr register.
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L657.
pub fn _reset_mconfigptr() -> xlenbits {
    zeros::<64>(64)
}

/// Initialize the tlb register.
/// 
/// Generated from the Sail sources at `riscv_vmem_tlb.sail` L73.
pub fn _reset_tlb() -> [Option<TLB_Entry>; (num_tlb_entries as usize)] {
    [None; 64]
}

/// Initialize the hart_state register.
/// 
/// Generated from the Sail sources at `riscv_step.sail` L11.
pub fn _reset_hart_state() -> HartState {
    HartState::HART_ACTIVE(())
}

/// neq_bool
/// 
/// Generated from the Sail sources at `sail/lib/flow.sail` L81.
pub fn neq_bool(x: bool, y: bool) -> bool {
    !((x == y))
}

/// __id
/// 
/// Generated from the Sail sources at `sail/lib/flow.sail` L107.
pub fn __id(x: i128) -> i128 {
    x
}

pub type xlenbits = BitVector<xlen>;

/// virtaddr
/// 
/// Generated from the Sail sources at `prelude_mem_addrtype.sail` L17.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum virtaddr {
    Virtaddr(xlenbits)
}

/// sub_virtaddr_xlenbits
/// 
/// Generated from the Sail sources at `prelude_mem_addrtype.sail` L23.
pub fn sub_virtaddr_xlenbits(virtaddr::Virtaddr(addr): virtaddr, offset: BitVector<{
    64
}>) -> virtaddr {
    virtaddr::Virtaddr(sub_vec(addr, offset))
}

/// hex_bits_forwards_matches
/// 
/// Generated from the Sail sources at `sail/lib/hex_bits.sail` L63.
pub const fn hex_bits_forwards_matches<const N: i128>(bv: BitVector<N>) -> bool {
    true
}

/// hex_bits_backwards
/// 
/// Generated from the Sail sources at `sail/lib/hex_bits.sail` L65.
pub fn hex_bits_backwards<const N: i128>(n: i128, str: &'static str) -> BitVector<N> {
    parse_hex_bits(n, str)
}

/// get_config_print_platform
/// 
/// Generated from the Sail sources at `prelude.sail` L75.
pub const fn get_config_print_platform(unit_arg: ()) -> bool {
    false
}

/// zeros
/// 
/// Generated from the Sail sources at `prelude.sail` L84.
pub const fn zeros<const N: i128>(n: i128) -> BitVector<N> {
    sail_zeros(n)
}

/// ones
/// 
/// Generated from the Sail sources at `prelude.sail` L87.
pub const fn ones<const N: i128>(n: i128) -> BitVector<N> {
    sail_ones(n)
}

/// bool_bit_backwards
/// 
/// Generated from the Sail sources.
pub fn bool_bit_backwards(arg_hashtag_: bool) -> bool {
    match arg_hashtag_ {
        true => {true}
        false => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_bits_forwards
/// 
/// Generated from the Sail sources.
pub fn bool_bits_forwards(arg_hashtag_: bool) -> BitVector<1> {
    match arg_hashtag_ {
        true => {BitVector::<1>::new(0b1)}
        false => {BitVector::<1>::new(0b0)}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_bits_backwards
/// 
/// Generated from the Sail sources.
pub fn bool_bits_backwards(arg_hashtag_: BitVector<1>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<1>::new(0b1))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_bits_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn bool_bits_backwards_matches(arg_hashtag_: BitVector<1>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<1>::new(0b1))} => {true}
        b__1 if {(b__1 == BitVector::<1>::new(0b0))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_not_bits_forwards
/// 
/// Generated from the Sail sources.
pub fn bool_not_bits_forwards(arg_hashtag_: bool) -> BitVector<1> {
    match arg_hashtag_ {
        true => {BitVector::<1>::new(0b0)}
        false => {BitVector::<1>::new(0b1)}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_not_bits_backwards
/// 
/// Generated from the Sail sources.
pub fn bool_not_bits_backwards(arg_hashtag_: BitVector<1>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<1>::new(0b0))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// bool_not_bits_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn bool_not_bits_backwards_matches(arg_hashtag_: BitVector<1>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<1>::new(0b0))} => {true}
        b__1 if {(b__1 == BitVector::<1>::new(0b1))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// bit_to_bool
/// 
/// Generated from the Sail sources at `prelude.sail` L111.
pub fn bit_to_bool(x: bool) -> bool {
    bool_bit_backwards(x)
}

/// bool_to_bits
/// 
/// Generated from the Sail sources at `prelude.sail` L112.
pub fn bool_to_bits(x: bool) -> BitVector<1> {
    bool_bits_forwards(x)
}

/// to_bits
/// 
/// Generated from the Sail sources at `prelude.sail` L117.
pub fn to_bits<const L: i128>(l: i128, n: i128) -> BitVector<L> {
    get_slice_int(l, n, 0)
}

/// (operator <_s)
/// 
/// Generated from the Sail sources at `prelude.sail` L137.
pub fn _operator_smaller_s_<const N: i128>(x: BitVector<N>, y: BitVector<N>) -> bool {
    (x.signed() < y.signed())
}

/// (operator >=_s)
/// 
/// Generated from the Sail sources at `prelude.sail` L140.
pub fn _operator_biggerequal_s_<const N: i128>(x: BitVector<N>, y: BitVector<N>) -> bool {
    (x.signed() >= y.signed())
}

/// (operator <_u)
/// 
/// Generated from the Sail sources at `prelude.sail` L141.
pub fn _operator_smaller_u_<const N: i128>(x: BitVector<N>, y: BitVector<N>) -> bool {
    (x.unsigned() < y.unsigned())
}

/// (operator >=_u)
/// 
/// Generated from the Sail sources at `prelude.sail` L144.
pub fn _operator_biggerequal_u_<const N: i128>(x: BitVector<N>, y: BitVector<N>) -> bool {
    (x.unsigned() >= y.unsigned())
}

/// shift_bits_right_arith
/// 
/// Generated from the Sail sources at `prelude.sail` L166-167.
pub fn shift_bits_right_arith<const M: i128, const N: i128>(value: BitVector<N>, shift: BitVector<M>) -> BitVector<N> {
    shift_right_arith(value, shift.unsigned())
}

/// rotate_bits_left
/// 
/// Generated from the Sail sources at `prelude.sail` L177-178.
pub fn rotate_bits_left<const N: i128, const M: i128>(v: BitVector<N>, n: BitVector<M>) -> BitVector<N> {
    (shift_bits_left(v, n) | shift_bits_right(v, sub_vec(to_bits(bitvector_length(n), bitvector_length(v)), n)))
}

/// rotatel
/// 
/// Generated from the Sail sources at `prelude.sail` L185-186.
pub fn rotatel<const M: i128>(v: BitVector<M>, n: i128) -> BitVector<M> {
    ((v << n) | (v >> (bitvector_length(v) - n)))
}

pub const max_mem_access: i128 = 4096;

pub type mem_access_width = i128;

/// exception
/// 
/// Generated from the Sail sources at `riscv_errors.sail` L11-14.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum exception {
    Error_not_implemented(&'static str),
    Error_internal_error(())
}

pub const log2_xlen: i128 = 6;

pub const log2_xlen_bytes: i128 = 3;

pub const xlen_bytes: i128 = 8;

pub const xlen: i128 = 64;

pub const asidlen: i128 = 16;

pub type asidbits = BitVector<asidlen>;

pub type flenbits = BitVector<flen>;

pub const flen_bytes: i128 = 8;

pub const flen: i128 = 64;

/// get_vlen_pow
/// 
/// Generated from the Sail sources at `riscv_vlen.sail` L16.
pub const fn get_vlen_pow(unit_arg: ()) -> i128 {
    3
}

pub const vlenmax: i128 = 65536;

pub const VLEN: i128 = 8;

pub type physaddrbits = BitVector<physaddrbits_len>;

pub const physaddrbits_len: i128 = 64;

/// physaddr
/// 
/// Generated from the Sail sources at `prelude_mem_addrtype.sail` L16.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum physaddr {
    Physaddr(physaddrbits)
}

/// bits_of_virtaddr
/// 
/// Generated from the Sail sources at `prelude_mem_addrtype.sail` L21.
pub fn bits_of_virtaddr(virtaddr::Virtaddr(vaddr): virtaddr) -> BitVector<{
    64
}> {
    vaddr
}

pub type mem_meta = ();

pub const default_meta: mem_meta = ();

/// result
/// 
/// Generated from the Sail sources at `sail/lib/result.sail` L60-63.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum result<A, B> {
    Ok(A),
    Err(B)
}

/// sail_branch_announce
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/common.sail` L92.
pub const fn sail_branch_announce<const ADDRSIZE: i128>(_: i128, _: BitVector<ADDRSIZE>) {
    ()
}

/// Access_variety
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/read_write.sail` L57-61.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Access_variety {
    AV_plain,
    AV_exclusive,
    AV_atomic_rmw
}

/// Access_strength
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/read_write.sail` L66-70.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Access_strength {
    AS_normal,
    AS_rel_or_acq,
    AS_acq_rcpc
}

/// Explicit_access_kind
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/read_write.sail` L75-78.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Explicit_access_kind {
    pub variety: Access_variety,
    pub strength: Access_strength,
}

/// Access_kind
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/read_write.sail` L83-88.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Access_kind<ARCH_AK> {
    AK_explicit(Explicit_access_kind),
    AK_ifetch(()),
    AK_ttw(()),
    AK_arch(ARCH_AK)
}

/// Mem_read_request
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/read_write.sail` L93-104.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Mem_read_request<const N: i128, const VASIZE: i128, PA, TS, ARCH_AK> {
    pub access_kind: Access_kind<ARCH_AK>,
    pub va: Option<BitVector<VASIZE>>,
    pub pa: PA,
    pub translation: TS,
    pub size: i128,
    pub tag: bool,
}

pub const __monomorphize_reads: bool = false;

pub const __monomorphize_writes: bool = false;

/// write_kind
/// 
/// Generated from the Sail sources at `prelude_mem.sail` L19-26.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum write_kind {
    Write_plain,
    Write_RISCV_release,
    Write_RISCV_strong_release,
    Write_RISCV_conditional,
    Write_RISCV_conditional_release,
    Write_RISCV_conditional_strong_release
}

/// read_kind
/// 
/// Generated from the Sail sources at `prelude_mem.sail` L28-36.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum read_kind {
    Read_plain,
    Read_ifetch,
    Read_RISCV_acquire,
    Read_RISCV_strong_acquire,
    Read_RISCV_reserved,
    Read_RISCV_reserved_acquire,
    Read_RISCV_reserved_strong_acquire
}

/// barrier_kind
/// 
/// Generated from the Sail sources at `prelude_mem.sail` L38-50.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum barrier_kind {
    Barrier_RISCV_rw_rw,
    Barrier_RISCV_r_rw,
    Barrier_RISCV_r_r,
    Barrier_RISCV_rw_w,
    Barrier_RISCV_w_w,
    Barrier_RISCV_w_rw,
    Barrier_RISCV_rw_r,
    Barrier_RISCV_r_w,
    Barrier_RISCV_w_r,
    Barrier_RISCV_tso,
    Barrier_RISCV_i
}

/// RISCV_strong_access
/// 
/// Generated from the Sail sources at `prelude_mem.sail` L55-57.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct RISCV_strong_access {
    pub variety: Access_variety,
}

/// sail_barrier
/// 
/// Generated from the Sail sources at `sail/lib/concurrency_interface/barrier.sail` L58.
pub const fn sail_barrier(_: barrier_kind) {
    ()
}

/// extension
/// 
/// Generated from the Sail sources at `riscv_extensions.sail` L10.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum extension {
    Ext_M,
    Ext_A,
    Ext_F,
    Ext_D,
    Ext_B,
    Ext_V,
    Ext_S,
    Ext_U,
    Ext_Zicbom,
    Ext_Zicboz,
    Ext_Zicntr,
    Ext_Zicond,
    Ext_Zifencei,
    Ext_Zihpm,
    Ext_Zimop,
    Ext_Zmmul,
    Ext_Zaamo,
    Ext_Zabha,
    Ext_Zalrsc,
    Ext_Zfa,
    Ext_Zfh,
    Ext_Zfhmin,
    Ext_Zfinx,
    Ext_Zdinx,
    Ext_Zca,
    Ext_Zcb,
    Ext_Zcd,
    Ext_Zcf,
    Ext_Zcmop,
    Ext_C,
    Ext_Zba,
    Ext_Zbb,
    Ext_Zbc,
    Ext_Zbkb,
    Ext_Zbkc,
    Ext_Zbkx,
    Ext_Zbs,
    Ext_Zknd,
    Ext_Zkne,
    Ext_Zknh,
    Ext_Zkr,
    Ext_Zksed,
    Ext_Zksh,
    Ext_Zhinx,
    Ext_Zvbb,
    Ext_Zvkb,
    Ext_Zvbc,
    Ext_Zvknha,
    Ext_Zvknhb,
    Ext_Zvksh,
    Ext_Sscofpmf,
    Ext_Sstc,
    Ext_Svinval,
    Ext_Svnapot,
    Ext_Svpbmt,
    Ext_Svbare,
    Ext_Sv32,
    Ext_Sv39,
    Ext_Sv48,
    Ext_Sv57,
    Ext_Smcntrpmf
}

/// hartSupports
/// 
/// Generated from the Sail sources at `riscv_extensions.sail` L32.
pub fn hartSupports(core_ctx: &mut Core, merge_hashtag_var: extension) -> bool {
    match merge_hashtag_var {
        extension::Ext_M => {core_ctx.config.extensions.M.supported}
        extension::Ext_A => {core_ctx.config.extensions.A.supported}
        extension::Ext_F => {core_ctx.config.extensions.FD.supported}
        extension::Ext_D => {core_ctx.config.extensions.FD.supported}
        extension::Ext_B => {core_ctx.config.extensions.B.supported}
        extension::Ext_V => {core_ctx.config.extensions.V.supported}
        extension::Ext_S => {core_ctx.config.extensions.S.supported}
        extension::Ext_U => {core_ctx.config.extensions.U.supported}
        extension::Ext_Zicbom => {core_ctx.config.extensions.Zicbom.supported}
        extension::Ext_Zicboz => {core_ctx.config.extensions.Zicboz.supported}
        extension::Ext_Zicntr => {core_ctx.config.extensions.Zicntr.supported}
        extension::Ext_Zicond => {core_ctx.config.extensions.Zicond.supported}
        extension::Ext_Zifencei => {core_ctx.config.extensions.Zifencei.supported}
        extension::Ext_Zihpm => {core_ctx.config.extensions.Zihpm.supported}
        extension::Ext_Zimop => {core_ctx.config.extensions.Zimop.supported}
        extension::Ext_Zmmul => {core_ctx.config.extensions.Zmmul.supported}
        extension::Ext_Zaamo => {core_ctx.config.extensions.Zaamo.supported}
        extension::Ext_Zabha => {core_ctx.config.extensions.Zabha.supported}
        extension::Ext_Zalrsc => {core_ctx.config.extensions.Zalrsc.supported}
        extension::Ext_Zfa => {core_ctx.config.extensions.Zfa.supported}
        extension::Ext_Zfh => {core_ctx.config.extensions.Zfh.supported}
        extension::Ext_Zfhmin => {core_ctx.config.extensions.Zfhmin.supported}
        extension::Ext_Zfinx => {core_ctx.config.extensions.Zfinx.supported}
        extension::Ext_Zdinx => {core_ctx.config.extensions.Zfinx.supported}
        extension::Ext_Zca => {core_ctx.config.extensions.Zca.supported}
        extension::Ext_Zcb => {core_ctx.config.extensions.Zcb.supported}
        extension::Ext_Zcd => {core_ctx.config.extensions.Zcd.supported}
        extension::Ext_Zcf => {false}
        extension::Ext_Zcmop => {core_ctx.config.extensions.Zcmop.supported}
        extension::Ext_C => {(hartSupports(core_ctx, extension::Ext_Zca) && ((hartSupports(core_ctx, extension::Ext_Zcf) || (!(hartSupports(core_ctx, extension::Ext_F)) || (64 != 32))) && (hartSupports(core_ctx, extension::Ext_Zcd) || !(hartSupports(core_ctx, extension::Ext_D)))))}
        extension::Ext_Zba => {core_ctx.config.extensions.Zba.supported}
        extension::Ext_Zbb => {core_ctx.config.extensions.Zbb.supported}
        extension::Ext_Zbc => {core_ctx.config.extensions.Zbc.supported}
        extension::Ext_Zbkb => {core_ctx.config.extensions.Zbkb.supported}
        extension::Ext_Zbkc => {core_ctx.config.extensions.Zbkc.supported}
        extension::Ext_Zbkx => {core_ctx.config.extensions.Zbkx.supported}
        extension::Ext_Zbs => {core_ctx.config.extensions.Zbs.supported}
        extension::Ext_Zknd => {core_ctx.config.extensions.Zknd.supported}
        extension::Ext_Zkne => {core_ctx.config.extensions.Zkne.supported}
        extension::Ext_Zknh => {core_ctx.config.extensions.Zknh.supported}
        extension::Ext_Zkr => {core_ctx.config.extensions.Zkr.supported}
        extension::Ext_Zksed => {core_ctx.config.extensions.Zksed.supported}
        extension::Ext_Zksh => {core_ctx.config.extensions.Zksh.supported}
        extension::Ext_Zhinx => {core_ctx.config.extensions.Zhinx.supported}
        extension::Ext_Zvbb => {core_ctx.config.extensions.Zvbb.supported}
        extension::Ext_Zvkb => {core_ctx.config.extensions.Zvkb.supported}
        extension::Ext_Zvbc => {core_ctx.config.extensions.Zvbc.supported}
        extension::Ext_Zvknha => {core_ctx.config.extensions.Zvknha.supported}
        extension::Ext_Zvknhb => {core_ctx.config.extensions.Zvknhb.supported}
        extension::Ext_Zvksh => {core_ctx.config.extensions.Zvksh.supported}
        extension::Ext_Sscofpmf => {core_ctx.config.extensions.Sscofpmf.supported}
        extension::Ext_Sstc => {core_ctx.config.extensions.Sstc.supported}
        extension::Ext_Svinval => {core_ctx.config.extensions.Svinval.supported}
        extension::Ext_Svnapot => {false}
        extension::Ext_Svpbmt => {false}
        extension::Ext_Svbare => {core_ctx.config.extensions.Svbare.supported}
        extension::Ext_Sv32 => {false}
        extension::Ext_Sv39 => {(core_ctx.config.extensions.Sv39.supported as bool)}
        extension::Ext_Sv48 => {(core_ctx.config.extensions.Sv48.supported as bool)}
        extension::Ext_Sv57 => {(core_ctx.config.extensions.Sv57.supported as bool)}
        extension::Ext_Smcntrpmf => {core_ctx.config.extensions.Smcntrpmf.supported}
        _ => {panic!("Unreachable code")}
    }
}

pub type exc_code = BitVector<8>;

pub type ext_ptw = ();

pub const init_ext_ptw: ext_ptw = ();

pub type ext_ptw_fail = ();

pub type ext_ptw_error = ();

pub type ext_exc_type = ();

/// ext_exc_type_to_bits
/// 
/// Generated from the Sail sources at `riscv_types_ext.sail` L61.
pub fn ext_exc_type_to_bits(unit_arg: ()) -> BitVector<8> {
    BitVector::<8>::new(0b00011000)
}

/// num_of_ext_exc_type
/// 
/// Generated from the Sail sources at `riscv_types_ext.sail` L65.
pub const fn num_of_ext_exc_type(unit_arg: ()) -> i128 {
    24
}

/// ext_exc_type_to_str
/// 
/// Generated from the Sail sources at `riscv_types_ext.sail` L69.
pub const fn ext_exc_type_to_str(unit_arg: ()) -> &'static str {
    "extension-exception"
}

pub const xlen_max_unsigned: i128 = 18446744073709551615;

pub const xlen_max_signed: i128 = 9223372036854775807;

pub const xlen_min_signed: i128 = -9223372036854775808;

pub type half = BitVector<16>;

pub type word = BitVector<32>;

pub type instbits = BitVector<32>;

pub const pagesize_bits: i128 = 12;

/// regidx
/// 
/// Generated from the Sail sources at `riscv_types.sail` L25.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum regidx {
    Regidx(BitVector<5>)
}

/// cregidx
/// 
/// Generated from the Sail sources at `riscv_types.sail` L26.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum cregidx {
    Cregidx(BitVector<3>)
}

pub type csreg = BitVector<12>;

/// regno
/// 
/// Generated from the Sail sources at `riscv_types.sail` L34.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum regno {
    Regno(i128)
}

/// regidx_to_regno
/// 
/// Generated from the Sail sources at `riscv_types.sail` L36.
pub fn regidx_to_regno(regidx::Regidx(b): regidx) -> regno {
    regno::Regno(b.unsigned())
}

/// regno_to_regidx
/// 
/// Generated from the Sail sources at `riscv_types.sail` L37.
pub fn regno_to_regidx(regno::Regno(b): regno) -> regidx {
    regidx::Regidx(to_bits::<5>(5, b))
}

/// creg2reg_idx
/// 
/// Generated from the Sail sources at `riscv_types.sail` L41.
pub fn creg2reg_idx(cregidx::Cregidx(i): cregidx) -> regidx {
    regidx::Regidx(bitvector_concat::<2, 3, 5>(BitVector::<2>::new(0b01), i))
}

pub const zreg: regidx = regidx::Regidx(BitVector::<5>::new(0b00000));

pub const ra: regidx = regidx::Regidx(BitVector::<5>::new(0b00001));

pub const sp: regidx = regidx::Regidx(BitVector::<5>::new(0b00010));

/// Architecture
/// 
/// Generated from the Sail sources at `riscv_types.sail` L50.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Architecture {
    RV32,
    RV64,
    RV128
}

pub type arch_xlen = BitVector<2>;

/// architecture_forwards
/// 
/// Generated from the Sail sources.
pub fn architecture_forwards(arg_hashtag_: Architecture) -> BitVector<2> {
    match arg_hashtag_ {
        Architecture::RV32 => {BitVector::<2>::new(0b01)}
        Architecture::RV64 => {BitVector::<2>::new(0b10)}
        Architecture::RV128 => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// architecture_backwards
/// 
/// Generated from the Sail sources.
pub fn architecture_backwards(arg_hashtag_: BitVector<2>) -> Architecture {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b01))} => {Architecture::RV32}
        b__1 if {(b__1 == BitVector::<2>::new(0b10))} => {Architecture::RV64}
        b__2 if {(b__2 == BitVector::<2>::new(0b11))} => {Architecture::RV128}
        _ => {panic!("{}, l {}: {}", "riscv_types.sail", 57, "architecture(0b00) is invalid")}
        _ => {panic!("Unreachable code")}
    }
}

pub type priv_level = BitVector<2>;

/// Privilege
/// 
/// Generated from the Sail sources at `riscv_types.sail` L63.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Privilege {
    User,
    Supervisor,
    Machine
}

/// privLevel_bits_forwards
/// 
/// Generated from the Sail sources.
pub fn privLevel_bits_forwards(arg_hashtag_: Privilege) -> BitVector<2> {
    match arg_hashtag_ {
        Privilege::User => {BitVector::<2>::new(0b00)}
        Privilege::Supervisor => {BitVector::<2>::new(0b01)}
        Privilege::Machine => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// privLevel_bits_backwards
/// 
/// Generated from the Sail sources.
pub fn privLevel_bits_backwards(arg_hashtag_: BitVector<2>) -> Privilege {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {Privilege::User}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {Privilege::Supervisor}
        b__2 if {(b__2 == BitVector::<2>::new(0b11))} => {Privilege::Machine}
        _ => {panic!("{}, l {}: {}", "riscv_types.sail", 69, format!("{}{}", "Invalid privilege level: ", bits_str(BitVector::<2>::new(0b10))))}
        _ => {panic!("Unreachable code")}
    }
}

/// privLevel_to_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L72.
pub fn privLevel_to_bits(p: Privilege) -> BitVector<2> {
    privLevel_bits_forwards(p)
}

/// privLevel_of_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L73.
pub fn privLevel_of_bits(b: BitVector<2>) -> Privilege {
    privLevel_bits_backwards(b)
}

/// privLevel_to_str
/// 
/// Generated from the Sail sources at `riscv_types.sail` L75-80.
pub fn privLevel_to_str(p: Privilege) -> &'static str {
    match p {
        Privilege::User => {"U"}
        Privilege::Supervisor => {"S"}
        Privilege::Machine => {"M"}
        _ => {panic!("Unreachable code")}
    }
}

/// AccessType
/// 
/// Generated from the Sail sources at `riscv_types.sail` L86-91.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum AccessType<A> {
    Read(A),
    Write(A),
    ReadWrite((A, A)),
    InstructionFetch(())
}

/// csr_name_map_forwards
/// 
/// Generated from the Sail sources.
pub fn csr_name_map_forwards(arg_hashtag_: BitVector<12>) -> &'static str {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<12>::new(0b001100000001))} => {"misa"}
        b__1 if {(b__1 == BitVector::<12>::new(0b001100000000))} => {"mstatus"}
        b__2 if {(b__2 == BitVector::<12>::new(0b001100001010))} => {"menvcfg"}
        b__3 if {(b__3 == BitVector::<12>::new(0b001100011010))} => {"menvcfgh"}
        b__4 if {(b__4 == BitVector::<12>::new(0b000100001010))} => {"senvcfg"}
        b__5 if {(b__5 == BitVector::<12>::new(0b001100000100))} => {"mie"}
        b__6 if {(b__6 == BitVector::<12>::new(0b001101000100))} => {"mip"}
        b__7 if {(b__7 == BitVector::<12>::new(0b001100000010))} => {"medeleg"}
        b__8 if {(b__8 == BitVector::<12>::new(0b001100010010))} => {"medelegh"}
        b__9 if {(b__9 == BitVector::<12>::new(0b001100000011))} => {"mideleg"}
        b__10 if {(b__10 == BitVector::<12>::new(0b001101000010))} => {"mcause"}
        b__11 if {(b__11 == BitVector::<12>::new(0b001101000011))} => {"mtval"}
        b__12 if {(b__12 == BitVector::<12>::new(0b001101000000))} => {"mscratch"}
        b__13 if {(b__13 == BitVector::<12>::new(0b000100000110))} => {"scounteren"}
        b__14 if {(b__14 == BitVector::<12>::new(0b001100000110))} => {"mcounteren"}
        b__15 if {(b__15 == BitVector::<12>::new(0b001100100000))} => {"mcountinhibit"}
        b__16 if {(b__16 == BitVector::<12>::new(0b111100010001))} => {"mvendorid"}
        b__17 if {(b__17 == BitVector::<12>::new(0b111100010010))} => {"marchid"}
        b__18 if {(b__18 == BitVector::<12>::new(0b111100010011))} => {"mimpid"}
        b__19 if {(b__19 == BitVector::<12>::new(0b111100010100))} => {"mhartid"}
        b__20 if {(b__20 == BitVector::<12>::new(0b111100010101))} => {"mconfigptr"}
        b__21 if {(b__21 == BitVector::<12>::new(0b000100000000))} => {"sstatus"}
        b__22 if {(b__22 == BitVector::<12>::new(0b000101000100))} => {"sip"}
        b__23 if {(b__23 == BitVector::<12>::new(0b000100000100))} => {"sie"}
        b__24 if {(b__24 == BitVector::<12>::new(0b000101000000))} => {"sscratch"}
        b__25 if {(b__25 == BitVector::<12>::new(0b000101000010))} => {"scause"}
        b__26 if {(b__26 == BitVector::<12>::new(0b000101000011))} => {"stval"}
        b__27 if {(b__27 == BitVector::<12>::new(0b011110100000))} => {"tselect"}
        b__28 if {(b__28 == BitVector::<12>::new(0b011110100001))} => {"tdata1"}
        b__29 if {(b__29 == BitVector::<12>::new(0b011110100010))} => {"tdata2"}
        b__30 if {(b__30 == BitVector::<12>::new(0b011110100011))} => {"tdata3"}
        b__31 if {(b__31 == BitVector::<12>::new(0b001110100000))} => {"pmpcfg0"}
        b__32 if {(b__32 == BitVector::<12>::new(0b001110100001))} => {"pmpcfg1"}
        b__33 if {(b__33 == BitVector::<12>::new(0b001110100010))} => {"pmpcfg2"}
        b__34 if {(b__34 == BitVector::<12>::new(0b001110100011))} => {"pmpcfg3"}
        b__35 if {(b__35 == BitVector::<12>::new(0b001110100100))} => {"pmpcfg4"}
        b__36 if {(b__36 == BitVector::<12>::new(0b001110100101))} => {"pmpcfg5"}
        b__37 if {(b__37 == BitVector::<12>::new(0b001110100110))} => {"pmpcfg6"}
        b__38 if {(b__38 == BitVector::<12>::new(0b001110100111))} => {"pmpcfg7"}
        b__39 if {(b__39 == BitVector::<12>::new(0b001110101000))} => {"pmpcfg8"}
        b__40 if {(b__40 == BitVector::<12>::new(0b001110101001))} => {"pmpcfg9"}
        b__41 if {(b__41 == BitVector::<12>::new(0b001110101010))} => {"pmpcfg10"}
        b__42 if {(b__42 == BitVector::<12>::new(0b001110101011))} => {"pmpcfg11"}
        b__43 if {(b__43 == BitVector::<12>::new(0b001110101100))} => {"pmpcfg12"}
        b__44 if {(b__44 == BitVector::<12>::new(0b001110101101))} => {"pmpcfg13"}
        b__45 if {(b__45 == BitVector::<12>::new(0b001110101110))} => {"pmpcfg14"}
        b__46 if {(b__46 == BitVector::<12>::new(0b001110101111))} => {"pmpcfg15"}
        b__47 if {(b__47 == BitVector::<12>::new(0b001110110000))} => {"pmpaddr0"}
        b__48 if {(b__48 == BitVector::<12>::new(0b001110110001))} => {"pmpaddr1"}
        b__49 if {(b__49 == BitVector::<12>::new(0b001110110010))} => {"pmpaddr2"}
        b__50 if {(b__50 == BitVector::<12>::new(0b001110110011))} => {"pmpaddr3"}
        b__51 if {(b__51 == BitVector::<12>::new(0b001110110100))} => {"pmpaddr4"}
        b__52 if {(b__52 == BitVector::<12>::new(0b001110110101))} => {"pmpaddr5"}
        b__53 if {(b__53 == BitVector::<12>::new(0b001110110110))} => {"pmpaddr6"}
        b__54 if {(b__54 == BitVector::<12>::new(0b001110110111))} => {"pmpaddr7"}
        b__55 if {(b__55 == BitVector::<12>::new(0b001110111000))} => {"pmpaddr8"}
        b__56 if {(b__56 == BitVector::<12>::new(0b001110111001))} => {"pmpaddr9"}
        b__57 if {(b__57 == BitVector::<12>::new(0b001110111010))} => {"pmpaddr10"}
        b__58 if {(b__58 == BitVector::<12>::new(0b001110111011))} => {"pmpaddr11"}
        b__59 if {(b__59 == BitVector::<12>::new(0b001110111100))} => {"pmpaddr12"}
        b__60 if {(b__60 == BitVector::<12>::new(0b001110111101))} => {"pmpaddr13"}
        b__61 if {(b__61 == BitVector::<12>::new(0b001110111110))} => {"pmpaddr14"}
        b__62 if {(b__62 == BitVector::<12>::new(0b001110111111))} => {"pmpaddr15"}
        b__63 if {(b__63 == BitVector::<12>::new(0b001111000000))} => {"pmpaddr16"}
        b__64 if {(b__64 == BitVector::<12>::new(0b001111000001))} => {"pmpaddr17"}
        b__65 if {(b__65 == BitVector::<12>::new(0b001111000010))} => {"pmpaddr18"}
        b__66 if {(b__66 == BitVector::<12>::new(0b001111000011))} => {"pmpaddr19"}
        b__67 if {(b__67 == BitVector::<12>::new(0b001111000100))} => {"pmpaddr20"}
        b__68 if {(b__68 == BitVector::<12>::new(0b001111000101))} => {"pmpaddr21"}
        b__69 if {(b__69 == BitVector::<12>::new(0b001111000110))} => {"pmpaddr22"}
        b__70 if {(b__70 == BitVector::<12>::new(0b001111000111))} => {"pmpaddr23"}
        b__71 if {(b__71 == BitVector::<12>::new(0b001111001000))} => {"pmpaddr24"}
        b__72 if {(b__72 == BitVector::<12>::new(0b001111001001))} => {"pmpaddr25"}
        b__73 if {(b__73 == BitVector::<12>::new(0b001111001010))} => {"pmpaddr26"}
        b__74 if {(b__74 == BitVector::<12>::new(0b001111001011))} => {"pmpaddr27"}
        b__75 if {(b__75 == BitVector::<12>::new(0b001111001100))} => {"pmpaddr28"}
        b__76 if {(b__76 == BitVector::<12>::new(0b001111001101))} => {"pmpaddr29"}
        b__77 if {(b__77 == BitVector::<12>::new(0b001111001110))} => {"pmpaddr30"}
        b__78 if {(b__78 == BitVector::<12>::new(0b001111001111))} => {"pmpaddr31"}
        b__79 if {(b__79 == BitVector::<12>::new(0b001111010000))} => {"pmpaddr32"}
        b__80 if {(b__80 == BitVector::<12>::new(0b001111010001))} => {"pmpaddr33"}
        b__81 if {(b__81 == BitVector::<12>::new(0b001111010010))} => {"pmpaddr34"}
        b__82 if {(b__82 == BitVector::<12>::new(0b001111010011))} => {"pmpaddr35"}
        b__83 if {(b__83 == BitVector::<12>::new(0b001111010100))} => {"pmpaddr36"}
        b__84 if {(b__84 == BitVector::<12>::new(0b001111010101))} => {"pmpaddr37"}
        b__85 if {(b__85 == BitVector::<12>::new(0b001111010110))} => {"pmpaddr38"}
        b__86 if {(b__86 == BitVector::<12>::new(0b001111010111))} => {"pmpaddr39"}
        b__87 if {(b__87 == BitVector::<12>::new(0b001111011000))} => {"pmpaddr40"}
        b__88 if {(b__88 == BitVector::<12>::new(0b001111011001))} => {"pmpaddr41"}
        b__89 if {(b__89 == BitVector::<12>::new(0b001111011010))} => {"pmpaddr42"}
        b__90 if {(b__90 == BitVector::<12>::new(0b001111011011))} => {"pmpaddr43"}
        b__91 if {(b__91 == BitVector::<12>::new(0b001111011100))} => {"pmpaddr44"}
        b__92 if {(b__92 == BitVector::<12>::new(0b001111011101))} => {"pmpaddr45"}
        b__93 if {(b__93 == BitVector::<12>::new(0b001111011110))} => {"pmpaddr46"}
        b__94 if {(b__94 == BitVector::<12>::new(0b001111011111))} => {"pmpaddr47"}
        b__95 if {(b__95 == BitVector::<12>::new(0b001111100000))} => {"pmpaddr48"}
        b__96 if {(b__96 == BitVector::<12>::new(0b001111100001))} => {"pmpaddr49"}
        b__97 if {(b__97 == BitVector::<12>::new(0b001111100010))} => {"pmpaddr50"}
        b__98 if {(b__98 == BitVector::<12>::new(0b001111100011))} => {"pmpaddr51"}
        b__99 if {(b__99 == BitVector::<12>::new(0b001111100100))} => {"pmpaddr52"}
        b__100 if {(b__100 == BitVector::<12>::new(0b001111100101))} => {"pmpaddr53"}
        b__101 if {(b__101 == BitVector::<12>::new(0b001111100110))} => {"pmpaddr54"}
        b__102 if {(b__102 == BitVector::<12>::new(0b001111100111))} => {"pmpaddr55"}
        b__103 if {(b__103 == BitVector::<12>::new(0b001111101000))} => {"pmpaddr56"}
        b__104 if {(b__104 == BitVector::<12>::new(0b001111101001))} => {"pmpaddr57"}
        b__105 if {(b__105 == BitVector::<12>::new(0b001111101010))} => {"pmpaddr58"}
        b__106 if {(b__106 == BitVector::<12>::new(0b001111101011))} => {"pmpaddr59"}
        b__107 if {(b__107 == BitVector::<12>::new(0b001111101100))} => {"pmpaddr60"}
        b__108 if {(b__108 == BitVector::<12>::new(0b001111101101))} => {"pmpaddr61"}
        b__109 if {(b__109 == BitVector::<12>::new(0b001111101110))} => {"pmpaddr62"}
        b__110 if {(b__110 == BitVector::<12>::new(0b001111101111))} => {"pmpaddr63"}
        b__111 if {(b__111 == BitVector::<12>::new(0b000000001000))} => {"vstart"}
        b__112 if {(b__112 == BitVector::<12>::new(0b000000001001))} => {"vxsat"}
        b__113 if {(b__113 == BitVector::<12>::new(0b000000001010))} => {"vxrm"}
        b__114 if {(b__114 == BitVector::<12>::new(0b000000001111))} => {"vcsr"}
        b__115 if {(b__115 == BitVector::<12>::new(0b110000100000))} => {"vl"}
        b__116 if {(b__116 == BitVector::<12>::new(0b110000100001))} => {"vtype"}
        b__117 if {(b__117 == BitVector::<12>::new(0b110000100010))} => {"vlenb"}
        b__118 if {(b__118 == BitVector::<12>::new(0b000100000101))} => {"stvec"}
        b__119 if {(b__119 == BitVector::<12>::new(0b000101000001))} => {"sepc"}
        b__120 if {(b__120 == BitVector::<12>::new(0b001100000101))} => {"mtvec"}
        b__121 if {(b__121 == BitVector::<12>::new(0b001101000001))} => {"mepc"}
        b__122 if {(b__122 == BitVector::<12>::new(0b110000000011))} => {"hpmcounter3"}
        b__123 if {(b__123 == BitVector::<12>::new(0b110000000100))} => {"hpmcounter4"}
        b__124 if {(b__124 == BitVector::<12>::new(0b110000000101))} => {"hpmcounter5"}
        b__125 if {(b__125 == BitVector::<12>::new(0b110000000110))} => {"hpmcounter6"}
        b__126 if {(b__126 == BitVector::<12>::new(0b110000000111))} => {"hpmcounter7"}
        b__127 if {(b__127 == BitVector::<12>::new(0b110000001000))} => {"hpmcounter8"}
        b__128 if {(b__128 == BitVector::<12>::new(0b110000001001))} => {"hpmcounter9"}
        b__129 if {(b__129 == BitVector::<12>::new(0b110000001010))} => {"hpmcounter10"}
        b__130 if {(b__130 == BitVector::<12>::new(0b110000001011))} => {"hpmcounter11"}
        b__131 if {(b__131 == BitVector::<12>::new(0b110000001100))} => {"hpmcounter12"}
        b__132 if {(b__132 == BitVector::<12>::new(0b110000001101))} => {"hpmcounter13"}
        b__133 if {(b__133 == BitVector::<12>::new(0b110000001110))} => {"hpmcounter14"}
        b__134 if {(b__134 == BitVector::<12>::new(0b110000001111))} => {"hpmcounter15"}
        b__135 if {(b__135 == BitVector::<12>::new(0b110000010000))} => {"hpmcounter16"}
        b__136 if {(b__136 == BitVector::<12>::new(0b110000010001))} => {"hpmcounter17"}
        b__137 if {(b__137 == BitVector::<12>::new(0b110000010010))} => {"hpmcounter18"}
        b__138 if {(b__138 == BitVector::<12>::new(0b110000010011))} => {"hpmcounter19"}
        b__139 if {(b__139 == BitVector::<12>::new(0b110000010100))} => {"hpmcounter20"}
        b__140 if {(b__140 == BitVector::<12>::new(0b110000010101))} => {"hpmcounter21"}
        b__141 if {(b__141 == BitVector::<12>::new(0b110000010110))} => {"hpmcounter22"}
        b__142 if {(b__142 == BitVector::<12>::new(0b110000010111))} => {"hpmcounter23"}
        b__143 if {(b__143 == BitVector::<12>::new(0b110000011000))} => {"hpmcounter24"}
        b__144 if {(b__144 == BitVector::<12>::new(0b110000011001))} => {"hpmcounter25"}
        b__145 if {(b__145 == BitVector::<12>::new(0b110000011010))} => {"hpmcounter26"}
        b__146 if {(b__146 == BitVector::<12>::new(0b110000011011))} => {"hpmcounter27"}
        b__147 if {(b__147 == BitVector::<12>::new(0b110000011100))} => {"hpmcounter28"}
        b__148 if {(b__148 == BitVector::<12>::new(0b110000011101))} => {"hpmcounter29"}
        b__149 if {(b__149 == BitVector::<12>::new(0b110000011110))} => {"hpmcounter30"}
        b__150 if {(b__150 == BitVector::<12>::new(0b110000011111))} => {"hpmcounter31"}
        b__151 if {(b__151 == BitVector::<12>::new(0b110010000011))} => {"hpmcounter3h"}
        b__152 if {(b__152 == BitVector::<12>::new(0b110010000100))} => {"hpmcounter4h"}
        b__153 if {(b__153 == BitVector::<12>::new(0b110010000101))} => {"hpmcounter5h"}
        b__154 if {(b__154 == BitVector::<12>::new(0b110010000110))} => {"hpmcounter6h"}
        b__155 if {(b__155 == BitVector::<12>::new(0b110010000111))} => {"hpmcounter7h"}
        b__156 if {(b__156 == BitVector::<12>::new(0b110010001000))} => {"hpmcounter8h"}
        b__157 if {(b__157 == BitVector::<12>::new(0b110010001001))} => {"hpmcounter9h"}
        b__158 if {(b__158 == BitVector::<12>::new(0b110010001010))} => {"hpmcounter10h"}
        b__159 if {(b__159 == BitVector::<12>::new(0b110010001011))} => {"hpmcounter11h"}
        b__160 if {(b__160 == BitVector::<12>::new(0b110010001100))} => {"hpmcounter12h"}
        b__161 if {(b__161 == BitVector::<12>::new(0b110010001101))} => {"hpmcounter13h"}
        b__162 if {(b__162 == BitVector::<12>::new(0b110010001110))} => {"hpmcounter14h"}
        b__163 if {(b__163 == BitVector::<12>::new(0b110010001111))} => {"hpmcounter15h"}
        b__164 if {(b__164 == BitVector::<12>::new(0b110010010000))} => {"hpmcounter16h"}
        b__165 if {(b__165 == BitVector::<12>::new(0b110010010001))} => {"hpmcounter17h"}
        b__166 if {(b__166 == BitVector::<12>::new(0b110010010010))} => {"hpmcounter18h"}
        b__167 if {(b__167 == BitVector::<12>::new(0b110010010011))} => {"hpmcounter19h"}
        b__168 if {(b__168 == BitVector::<12>::new(0b110010010100))} => {"hpmcounter20h"}
        b__169 if {(b__169 == BitVector::<12>::new(0b110010010101))} => {"hpmcounter21h"}
        b__170 if {(b__170 == BitVector::<12>::new(0b110010010110))} => {"hpmcounter22h"}
        b__171 if {(b__171 == BitVector::<12>::new(0b110010010111))} => {"hpmcounter23h"}
        b__172 if {(b__172 == BitVector::<12>::new(0b110010011000))} => {"hpmcounter24h"}
        b__173 if {(b__173 == BitVector::<12>::new(0b110010011001))} => {"hpmcounter25h"}
        b__174 if {(b__174 == BitVector::<12>::new(0b110010011010))} => {"hpmcounter26h"}
        b__175 if {(b__175 == BitVector::<12>::new(0b110010011011))} => {"hpmcounter27h"}
        b__176 if {(b__176 == BitVector::<12>::new(0b110010011100))} => {"hpmcounter28h"}
        b__177 if {(b__177 == BitVector::<12>::new(0b110010011101))} => {"hpmcounter29h"}
        b__178 if {(b__178 == BitVector::<12>::new(0b110010011110))} => {"hpmcounter30h"}
        b__179 if {(b__179 == BitVector::<12>::new(0b110010011111))} => {"hpmcounter31h"}
        b__180 if {(b__180 == BitVector::<12>::new(0b001100100011))} => {"mhpmevent3"}
        b__181 if {(b__181 == BitVector::<12>::new(0b001100100100))} => {"mhpmevent4"}
        b__182 if {(b__182 == BitVector::<12>::new(0b001100100101))} => {"mhpmevent5"}
        b__183 if {(b__183 == BitVector::<12>::new(0b001100100110))} => {"mhpmevent6"}
        b__184 if {(b__184 == BitVector::<12>::new(0b001100100111))} => {"mhpmevent7"}
        b__185 if {(b__185 == BitVector::<12>::new(0b001100101000))} => {"mhpmevent8"}
        b__186 if {(b__186 == BitVector::<12>::new(0b001100101001))} => {"mhpmevent9"}
        b__187 if {(b__187 == BitVector::<12>::new(0b001100101010))} => {"mhpmevent10"}
        b__188 if {(b__188 == BitVector::<12>::new(0b001100101011))} => {"mhpmevent11"}
        b__189 if {(b__189 == BitVector::<12>::new(0b001100101100))} => {"mhpmevent12"}
        b__190 if {(b__190 == BitVector::<12>::new(0b001100101101))} => {"mhpmevent13"}
        b__191 if {(b__191 == BitVector::<12>::new(0b001100101110))} => {"mhpmevent14"}
        b__192 if {(b__192 == BitVector::<12>::new(0b001100101111))} => {"mhpmevent15"}
        b__193 if {(b__193 == BitVector::<12>::new(0b001100110000))} => {"mhpmevent16"}
        b__194 if {(b__194 == BitVector::<12>::new(0b001100110001))} => {"mhpmevent17"}
        b__195 if {(b__195 == BitVector::<12>::new(0b001100110010))} => {"mhpmevent18"}
        b__196 if {(b__196 == BitVector::<12>::new(0b001100110011))} => {"mhpmevent19"}
        b__197 if {(b__197 == BitVector::<12>::new(0b001100110100))} => {"mhpmevent20"}
        b__198 if {(b__198 == BitVector::<12>::new(0b001100110101))} => {"mhpmevent21"}
        b__199 if {(b__199 == BitVector::<12>::new(0b001100110110))} => {"mhpmevent22"}
        b__200 if {(b__200 == BitVector::<12>::new(0b001100110111))} => {"mhpmevent23"}
        b__201 if {(b__201 == BitVector::<12>::new(0b001100111000))} => {"mhpmevent24"}
        b__202 if {(b__202 == BitVector::<12>::new(0b001100111001))} => {"mhpmevent25"}
        b__203 if {(b__203 == BitVector::<12>::new(0b001100111010))} => {"mhpmevent26"}
        b__204 if {(b__204 == BitVector::<12>::new(0b001100111011))} => {"mhpmevent27"}
        b__205 if {(b__205 == BitVector::<12>::new(0b001100111100))} => {"mhpmevent28"}
        b__206 if {(b__206 == BitVector::<12>::new(0b001100111101))} => {"mhpmevent29"}
        b__207 if {(b__207 == BitVector::<12>::new(0b001100111110))} => {"mhpmevent30"}
        b__208 if {(b__208 == BitVector::<12>::new(0b001100111111))} => {"mhpmevent31"}
        b__209 if {(b__209 == BitVector::<12>::new(0b101100000011))} => {"mhpmcounter3"}
        b__210 if {(b__210 == BitVector::<12>::new(0b101100000100))} => {"mhpmcounter4"}
        b__211 if {(b__211 == BitVector::<12>::new(0b101100000101))} => {"mhpmcounter5"}
        b__212 if {(b__212 == BitVector::<12>::new(0b101100000110))} => {"mhpmcounter6"}
        b__213 if {(b__213 == BitVector::<12>::new(0b101100000111))} => {"mhpmcounter7"}
        b__214 if {(b__214 == BitVector::<12>::new(0b101100001000))} => {"mhpmcounter8"}
        b__215 if {(b__215 == BitVector::<12>::new(0b101100001001))} => {"mhpmcounter9"}
        b__216 if {(b__216 == BitVector::<12>::new(0b101100001010))} => {"mhpmcounter10"}
        b__217 if {(b__217 == BitVector::<12>::new(0b101100001011))} => {"mhpmcounter11"}
        b__218 if {(b__218 == BitVector::<12>::new(0b101100001100))} => {"mhpmcounter12"}
        b__219 if {(b__219 == BitVector::<12>::new(0b101100001101))} => {"mhpmcounter13"}
        b__220 if {(b__220 == BitVector::<12>::new(0b101100001110))} => {"mhpmcounter14"}
        b__221 if {(b__221 == BitVector::<12>::new(0b101100001111))} => {"mhpmcounter15"}
        b__222 if {(b__222 == BitVector::<12>::new(0b101100010000))} => {"mhpmcounter16"}
        b__223 if {(b__223 == BitVector::<12>::new(0b101100010001))} => {"mhpmcounter17"}
        b__224 if {(b__224 == BitVector::<12>::new(0b101100010010))} => {"mhpmcounter18"}
        b__225 if {(b__225 == BitVector::<12>::new(0b101100010011))} => {"mhpmcounter19"}
        b__226 if {(b__226 == BitVector::<12>::new(0b101100010100))} => {"mhpmcounter20"}
        b__227 if {(b__227 == BitVector::<12>::new(0b101100010101))} => {"mhpmcounter21"}
        b__228 if {(b__228 == BitVector::<12>::new(0b101100010110))} => {"mhpmcounter22"}
        b__229 if {(b__229 == BitVector::<12>::new(0b101100010111))} => {"mhpmcounter23"}
        b__230 if {(b__230 == BitVector::<12>::new(0b101100011000))} => {"mhpmcounter24"}
        b__231 if {(b__231 == BitVector::<12>::new(0b101100011001))} => {"mhpmcounter25"}
        b__232 if {(b__232 == BitVector::<12>::new(0b101100011010))} => {"mhpmcounter26"}
        b__233 if {(b__233 == BitVector::<12>::new(0b101100011011))} => {"mhpmcounter27"}
        b__234 if {(b__234 == BitVector::<12>::new(0b101100011100))} => {"mhpmcounter28"}
        b__235 if {(b__235 == BitVector::<12>::new(0b101100011101))} => {"mhpmcounter29"}
        b__236 if {(b__236 == BitVector::<12>::new(0b101100011110))} => {"mhpmcounter30"}
        b__237 if {(b__237 == BitVector::<12>::new(0b101100011111))} => {"mhpmcounter31"}
        b__238 if {(b__238 == BitVector::<12>::new(0b101110000011))} => {"mhpmcounter3h"}
        b__239 if {(b__239 == BitVector::<12>::new(0b101110000100))} => {"mhpmcounter4h"}
        b__240 if {(b__240 == BitVector::<12>::new(0b101110000101))} => {"mhpmcounter5h"}
        b__241 if {(b__241 == BitVector::<12>::new(0b101110000110))} => {"mhpmcounter6h"}
        b__242 if {(b__242 == BitVector::<12>::new(0b101110000111))} => {"mhpmcounter7h"}
        b__243 if {(b__243 == BitVector::<12>::new(0b101110001000))} => {"mhpmcounter8h"}
        b__244 if {(b__244 == BitVector::<12>::new(0b101110001001))} => {"mhpmcounter9h"}
        b__245 if {(b__245 == BitVector::<12>::new(0b101110001010))} => {"mhpmcounter10h"}
        b__246 if {(b__246 == BitVector::<12>::new(0b101110001011))} => {"mhpmcounter11h"}
        b__247 if {(b__247 == BitVector::<12>::new(0b101110001100))} => {"mhpmcounter12h"}
        b__248 if {(b__248 == BitVector::<12>::new(0b101110001101))} => {"mhpmcounter13h"}
        b__249 if {(b__249 == BitVector::<12>::new(0b101110001110))} => {"mhpmcounter14h"}
        b__250 if {(b__250 == BitVector::<12>::new(0b101110001111))} => {"mhpmcounter15h"}
        b__251 if {(b__251 == BitVector::<12>::new(0b101110010000))} => {"mhpmcounter16h"}
        b__252 if {(b__252 == BitVector::<12>::new(0b101110010001))} => {"mhpmcounter17h"}
        b__253 if {(b__253 == BitVector::<12>::new(0b101110010010))} => {"mhpmcounter18h"}
        b__254 if {(b__254 == BitVector::<12>::new(0b101110010011))} => {"mhpmcounter19h"}
        b__255 if {(b__255 == BitVector::<12>::new(0b101110010100))} => {"mhpmcounter20h"}
        b__256 if {(b__256 == BitVector::<12>::new(0b101110010101))} => {"mhpmcounter21h"}
        b__257 if {(b__257 == BitVector::<12>::new(0b101110010110))} => {"mhpmcounter22h"}
        b__258 if {(b__258 == BitVector::<12>::new(0b101110010111))} => {"mhpmcounter23h"}
        b__259 if {(b__259 == BitVector::<12>::new(0b101110011000))} => {"mhpmcounter24h"}
        b__260 if {(b__260 == BitVector::<12>::new(0b101110011001))} => {"mhpmcounter25h"}
        b__261 if {(b__261 == BitVector::<12>::new(0b101110011010))} => {"mhpmcounter26h"}
        b__262 if {(b__262 == BitVector::<12>::new(0b101110011011))} => {"mhpmcounter27h"}
        b__263 if {(b__263 == BitVector::<12>::new(0b101110011100))} => {"mhpmcounter28h"}
        b__264 if {(b__264 == BitVector::<12>::new(0b101110011101))} => {"mhpmcounter29h"}
        b__265 if {(b__265 == BitVector::<12>::new(0b101110011110))} => {"mhpmcounter30h"}
        b__266 if {(b__266 == BitVector::<12>::new(0b101110011111))} => {"mhpmcounter31h"}
        b__267 if {(b__267 == BitVector::<12>::new(0b101110000011))} => {"mhpmcounter3h"}
        b__268 if {(b__268 == BitVector::<12>::new(0b101110000100))} => {"mhpmcounter4h"}
        b__269 if {(b__269 == BitVector::<12>::new(0b101110000101))} => {"mhpmcounter5h"}
        b__270 if {(b__270 == BitVector::<12>::new(0b101110000110))} => {"mhpmcounter6h"}
        b__271 if {(b__271 == BitVector::<12>::new(0b101110000111))} => {"mhpmcounter7h"}
        b__272 if {(b__272 == BitVector::<12>::new(0b101110001000))} => {"mhpmcounter8h"}
        b__273 if {(b__273 == BitVector::<12>::new(0b101110001001))} => {"mhpmcounter9h"}
        b__274 if {(b__274 == BitVector::<12>::new(0b101110001010))} => {"mhpmcounter10h"}
        b__275 if {(b__275 == BitVector::<12>::new(0b101110001011))} => {"mhpmcounter11h"}
        b__276 if {(b__276 == BitVector::<12>::new(0b101110001100))} => {"mhpmcounter12h"}
        b__277 if {(b__277 == BitVector::<12>::new(0b101110001101))} => {"mhpmcounter13h"}
        b__278 if {(b__278 == BitVector::<12>::new(0b101110001110))} => {"mhpmcounter14h"}
        b__279 if {(b__279 == BitVector::<12>::new(0b101110001111))} => {"mhpmcounter15h"}
        b__280 if {(b__280 == BitVector::<12>::new(0b101110010000))} => {"mhpmcounter16h"}
        b__281 if {(b__281 == BitVector::<12>::new(0b101110010001))} => {"mhpmcounter17h"}
        b__282 if {(b__282 == BitVector::<12>::new(0b101110010010))} => {"mhpmcounter18h"}
        b__283 if {(b__283 == BitVector::<12>::new(0b101110010011))} => {"mhpmcounter19h"}
        b__284 if {(b__284 == BitVector::<12>::new(0b101110010100))} => {"mhpmcounter20h"}
        b__285 if {(b__285 == BitVector::<12>::new(0b101110010101))} => {"mhpmcounter21h"}
        b__286 if {(b__286 == BitVector::<12>::new(0b101110010110))} => {"mhpmcounter22h"}
        b__287 if {(b__287 == BitVector::<12>::new(0b101110010111))} => {"mhpmcounter23h"}
        b__288 if {(b__288 == BitVector::<12>::new(0b101110011000))} => {"mhpmcounter24h"}
        b__289 if {(b__289 == BitVector::<12>::new(0b101110011001))} => {"mhpmcounter25h"}
        b__290 if {(b__290 == BitVector::<12>::new(0b101110011010))} => {"mhpmcounter26h"}
        b__291 if {(b__291 == BitVector::<12>::new(0b101110011011))} => {"mhpmcounter27h"}
        b__292 if {(b__292 == BitVector::<12>::new(0b101110011100))} => {"mhpmcounter28h"}
        b__293 if {(b__293 == BitVector::<12>::new(0b101110011101))} => {"mhpmcounter29h"}
        b__294 if {(b__294 == BitVector::<12>::new(0b101110011110))} => {"mhpmcounter30h"}
        b__295 if {(b__295 == BitVector::<12>::new(0b101110011111))} => {"mhpmcounter31h"}
        b__296 if {(b__296 == BitVector::<12>::new(0b110110100000))} => {"scountovf"}
        b__297 if {(b__297 == BitVector::<12>::new(0b000000010101))} => {"seed"}
        b__298 if {(b__298 == BitVector::<12>::new(0b110000000000))} => {"cycle"}
        b__299 if {(b__299 == BitVector::<12>::new(0b110000000001))} => {"time"}
        b__300 if {(b__300 == BitVector::<12>::new(0b110000000010))} => {"instret"}
        b__301 if {(b__301 == BitVector::<12>::new(0b110010000000))} => {"cycleh"}
        b__302 if {(b__302 == BitVector::<12>::new(0b110010000001))} => {"timeh"}
        b__303 if {(b__303 == BitVector::<12>::new(0b110010000010))} => {"instreth"}
        b__304 if {(b__304 == BitVector::<12>::new(0b101100000000))} => {"mcycle"}
        b__305 if {(b__305 == BitVector::<12>::new(0b101100000010))} => {"minstret"}
        b__306 if {(b__306 == BitVector::<12>::new(0b101110000000))} => {"mcycleh"}
        b__307 if {(b__307 == BitVector::<12>::new(0b101110000010))} => {"minstreth"}
        b__308 if {(b__308 == BitVector::<12>::new(0b000000000001))} => {"fflags"}
        b__309 if {(b__309 == BitVector::<12>::new(0b000000000010))} => {"frm"}
        b__310 if {(b__310 == BitVector::<12>::new(0b000000000011))} => {"fcsr"}
        b__311 if {(b__311 == BitVector::<12>::new(0b001100100001))} => {"mcyclecfg"}
        b__312 if {(b__312 == BitVector::<12>::new(0b011100100001))} => {"mcyclecfgh"}
        b__313 if {(b__313 == BitVector::<12>::new(0b001100100010))} => {"minstretcfg"}
        b__314 if {(b__314 == BitVector::<12>::new(0b011100100010))} => {"minstretcfgh"}
        b__315 if {(b__315 == BitVector::<12>::new(0b000101001101))} => {"stimecmp"}
        b__316 if {(b__316 == BitVector::<12>::new(0b000101011101))} => {"stimecmph"}
        b__317 if {(b__317 == BitVector::<12>::new(0b000110000000))} => {"satp"}
        reg => {hex_bits_12_forwards(reg)}
        _ => {panic!("Unreachable code")}
    }
}

/// ExceptionType
/// 
/// Generated from the Sail sources at `riscv_types.sail` L125-145.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ExceptionType {
    E_Fetch_Addr_Align(()),
    E_Fetch_Access_Fault(()),
    E_Illegal_Instr(()),
    E_Breakpoint(()),
    E_Load_Addr_Align(()),
    E_Load_Access_Fault(()),
    E_SAMO_Addr_Align(()),
    E_SAMO_Access_Fault(()),
    E_U_EnvCall(()),
    E_S_EnvCall(()),
    E_Reserved_10(()),
    E_M_EnvCall(()),
    E_Fetch_Page_Fault(()),
    E_Load_Page_Fault(()),
    E_Reserved_14(()),
    E_SAMO_Page_Fault(()),
    E_Extension(ext_exc_type)
}

/// exceptionType_to_str
/// 
/// Generated from the Sail sources at `riscv_types.sail` L197-218.
pub fn exceptionType_to_str(e: ExceptionType) -> &'static str {
    match e {
        ExceptionType::E_Fetch_Addr_Align(()) => {"misaligned-fetch"}
        ExceptionType::E_Fetch_Access_Fault(()) => {"fetch-access-fault"}
        ExceptionType::E_Illegal_Instr(()) => {"illegal-instruction"}
        ExceptionType::E_Breakpoint(()) => {"breakpoint"}
        ExceptionType::E_Load_Addr_Align(()) => {"misaligned-load"}
        ExceptionType::E_Load_Access_Fault(()) => {"load-access-fault"}
        ExceptionType::E_SAMO_Addr_Align(()) => {"misaligned-store/amo"}
        ExceptionType::E_SAMO_Access_Fault(()) => {"store/amo-access-fault"}
        ExceptionType::E_U_EnvCall(()) => {"u-call"}
        ExceptionType::E_S_EnvCall(()) => {"s-call"}
        ExceptionType::E_Reserved_10(()) => {"reserved-0"}
        ExceptionType::E_M_EnvCall(()) => {"m-call"}
        ExceptionType::E_Fetch_Page_Fault(()) => {"fetch-page-fault"}
        ExceptionType::E_Load_Page_Fault(()) => {"load-page-fault"}
        ExceptionType::E_Reserved_14(()) => {"reserved-1"}
        ExceptionType::E_SAMO_Page_Fault(()) => {"store/amo-page-fault"}
        ExceptionType::E_Extension(e) => {"extension-exception"}
        _ => {panic!("Unreachable code")}
    }
}

/// amoop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L279-280.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum amoop {
    AMOSWAP,
    AMOADD,
    AMOXOR,
    AMOAND,
    AMOOR,
    AMOMIN,
    AMOMAX,
    AMOMINU,
    AMOMAXU
}

/// bop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L271.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum bop {
    BEQ,
    BNE,
    BLT,
    BGE,
    BLTU,
    BGEU
}

/// cbop_zicbom
/// 
/// Generated from the Sail sources at `riscv_types.sail` L283.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum cbop_zicbom {
    CBO_CLEAN,
    CBO_FLUSH,
    CBO_INVAL
}

/// csrop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L281.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum csrop {
    CSRRW,
    CSRRS,
    CSRRC
}

/// f_bin_f_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L90.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_f_op_D {
    FSGNJ_D,
    FSGNJN_D,
    FSGNJX_D,
    FMIN_D,
    FMAX_D
}

/// f_bin_f_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L52.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_f_op_H {
    FSGNJ_H,
    FSGNJN_H,
    FSGNJX_H,
    FMIN_H,
    FMAX_H
}

/// f_bin_rm_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L80.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_rm_op_D {
    FADD_D,
    FSUB_D,
    FMUL_D,
    FDIV_D
}

/// f_bin_rm_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L38.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_rm_op_H {
    FADD_H,
    FSUB_H,
    FMUL_H,
    FDIV_H
}

/// f_bin_rm_op_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L60.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_rm_op_S {
    FADD_S,
    FSUB_S,
    FMUL_S,
    FDIV_S
}

/// f_bin_op_f_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L74.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_op_f_S {
    FSGNJ_S,
    FSGNJN_S,
    FSGNJX_S,
    FMIN_S,
    FMAX_S
}

/// f_bin_op_x_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L76.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_op_x_S {
    FEQ_S,
    FLT_S,
    FLE_S
}

/// f_bin_x_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L92.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_x_op_D {
    FEQ_D,
    FLT_D,
    FLE_D
}

/// f_bin_x_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L54.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_bin_x_op_H {
    FEQ_H,
    FLT_H,
    FLE_H
}

/// f_madd_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L78.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_madd_op_D {
    FMADD_D,
    FMSUB_D,
    FNMSUB_D,
    FNMADD_D
}

/// f_madd_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L36.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_madd_op_H {
    FMADD_H,
    FMSUB_H,
    FNMSUB_H,
    FNMADD_H
}

/// f_madd_op_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L58.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_madd_op_S {
    FMADD_S,
    FMSUB_S,
    FNMSUB_S,
    FNMADD_S
}

/// f_un_f_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L97.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_f_op_D {
    FMV_D_X
}

/// f_un_f_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L50.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_f_op_H {
    FMV_H_X
}

/// f_un_rm_ff_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L82.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_ff_op_D {
    FSQRT_D,
    FCVT_S_D,
    FCVT_D_S
}

/// f_un_rm_ff_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L40.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_ff_op_H {
    FSQRT_H,
    FCVT_H_S,
    FCVT_H_D,
    FCVT_S_H,
    FCVT_D_H
}

/// f_un_rm_fx_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L84-85.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_fx_op_D {
    FCVT_W_D,
    FCVT_WU_D,
    FCVT_L_D,
    FCVT_LU_D
}

/// f_un_rm_fx_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L42-43.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_fx_op_H {
    FCVT_W_H,
    FCVT_WU_H,
    FCVT_L_H,
    FCVT_LU_H
}

/// f_un_rm_fx_op_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L64-65.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_fx_op_S {
    FCVT_W_S,
    FCVT_WU_S,
    FCVT_L_S,
    FCVT_LU_S
}

/// f_un_rm_xf_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L87-88.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_xf_op_D {
    FCVT_D_W,
    FCVT_D_WU,
    FCVT_D_L,
    FCVT_D_LU
}

/// f_un_rm_xf_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L45-46.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_xf_op_H {
    FCVT_H_W,
    FCVT_H_WU,
    FCVT_H_L,
    FCVT_H_LU
}

/// f_un_rm_xf_op_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L67-68.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_xf_op_S {
    FCVT_S_W,
    FCVT_S_WU,
    FCVT_S_L,
    FCVT_S_LU
}

/// f_un_op_f_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L70.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_op_f_S {
    FMV_W_X
}

/// f_un_op_x_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L72.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_op_x_S {
    FCLASS_S,
    FMV_X_W
}

/// f_un_x_op_D
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L94-95.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_x_op_D {
    FCLASS_D,
    FMV_X_D
}

/// f_un_x_op_H
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L48.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_x_op_H {
    FCLASS_H,
    FMV_X_H
}

/// fregidx
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L55.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fregidx {
    Fregidx(BitVector<5>)
}

/// rounding_mode
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L56.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum rounding_mode {
    RM_RNE,
    RM_RTZ,
    RM_RDN,
    RM_RUP,
    RM_RMM,
    RM_DYN
}

/// fvfmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L138.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvfmafunct6 {
    VF_VMADD,
    VF_VNMADD,
    VF_VMSUB,
    VF_VNMSUB,
    VF_VMACC,
    VF_VNMACC,
    VF_VMSAC,
    VF_VNMSAC
}

/// fvfmfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L146.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvfmfunct6 {
    VFM_VMFEQ,
    VFM_VMFLE,
    VFM_VMFLT,
    VFM_VMFNE,
    VFM_VMFGT,
    VFM_VMFGE
}

/// fvffunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L135-136.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvffunct6 {
    VF_VADD,
    VF_VSUB,
    VF_VMIN,
    VF_VMAX,
    VF_VSGNJ,
    VF_VSGNJN,
    VF_VSGNJX,
    VF_VDIV,
    VF_VRDIV,
    VF_VMUL,
    VF_VRSUB,
    VF_VSLIDE1UP,
    VF_VSLIDE1DOWN
}

/// fvvmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L115.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvvmafunct6 {
    FVV_VMADD,
    FVV_VNMADD,
    FVV_VMSUB,
    FVV_VNMSUB,
    FVV_VMACC,
    FVV_VNMACC,
    FVV_VMSAC,
    FVV_VNMSAC
}

/// fvvmfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L123.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvvmfunct6 {
    FVVM_VMFEQ,
    FVVM_VMFLE,
    FVVM_VMFLT,
    FVVM_VMFNE
}

/// fvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L112-113.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fvvfunct6 {
    FVV_VADD,
    FVV_VSUB,
    FVV_VMIN,
    FVV_VMAX,
    FVV_VSGNJ,
    FVV_VSGNJN,
    FVV_VSGNJX,
    FVV_VDIV,
    FVV_VMUL
}

/// fwffunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L144.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwffunct6 {
    FWF_VADD,
    FWF_VSUB
}

/// fwvfmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L142.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwvfmafunct6 {
    FWVF_VMACC,
    FWVF_VNMACC,
    FWVF_VMSAC,
    FWVF_VNMSAC
}

/// fwvffunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L140.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwvffunct6 {
    FWVF_VADD,
    FWVF_VSUB,
    FWVF_VMUL
}

/// fwvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L121.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwvfunct6 {
    FWV_VADD,
    FWV_VSUB
}

/// fwvvmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L119.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwvvmafunct6 {
    FWVV_VMACC,
    FWVV_VNMACC,
    FWVV_VMSAC,
    FWVV_VNMSAC
}

/// fwvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L117.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fwvvfunct6 {
    FWVV_VADD,
    FWVV_VSUB,
    FWVV_VMUL
}

/// iop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L272.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum iop {
    ADDI,
    SLTI,
    SLTIU,
    XORI,
    ORI,
    ANDI
}

/// mmfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L55.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum mmfunct6 {
    MM_VMAND,
    MM_VMNAND,
    MM_VMANDN,
    MM_VMXOR,
    MM_VMOR,
    MM_VMNOR,
    MM_VMORN,
    MM_VMXNOR
}

/// mul_op
/// 
/// Generated from the Sail sources at `riscv_types.sail` L325-329.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct mul_op {
    pub high: bool,
    pub signed_rs1: bool,
    pub signed_rs2: bool,
}

/// mvvmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L89.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum mvvmafunct6 {
    MVV_VMACC,
    MVV_VNMSAC,
    MVV_VMADD,
    MVV_VNMSUB
}

/// mvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L86-87.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum mvvfunct6 {
    MVV_VAADDU,
    MVV_VAADD,
    MVV_VASUBU,
    MVV_VASUB,
    MVV_VMUL,
    MVV_VMULH,
    MVV_VMULHU,
    MVV_VMULHSU,
    MVV_VDIVU,
    MVV_VDIV,
    MVV_VREMU,
    MVV_VREM
}

/// mvxmafunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L104.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum mvxmafunct6 {
    MVX_VMACC,
    MVX_VNMSAC,
    MVX_VMADD,
    MVX_VNMSUB
}

/// mvxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L101-102.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum mvxfunct6 {
    MVX_VAADDU,
    MVX_VAADD,
    MVX_VASUBU,
    MVX_VASUB,
    MVX_VSLIDE1UP,
    MVX_VSLIDE1DOWN,
    MVX_VMUL,
    MVX_VMULH,
    MVX_VMULHU,
    MVX_VMULHSU,
    MVX_VDIVU,
    MVX_VDIV,
    MVX_VREMU,
    MVX_VREM
}

/// nisfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L59.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nisfunct6 {
    NIS_VNSRL,
    NIS_VNSRA
}

/// nifunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L57.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nifunct6 {
    NI_VNCLIPU,
    NI_VNCLIP
}

/// nvsfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L49.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nvsfunct6 {
    NVS_VNSRL,
    NVS_VNSRA
}

/// nvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L47.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nvfunct6 {
    NV_VNCLIPU,
    NV_VNCLIP
}

/// nxsfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L53.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nxsfunct6 {
    NXS_VNSRL,
    NXS_VNSRA
}

/// nxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L51.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum nxfunct6 {
    NX_VNCLIPU,
    NX_VNCLIP
}

/// rfvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L96-97.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum rfvvfunct6 {
    FVV_VFREDOSUM,
    FVV_VFREDUSUM,
    FVV_VFREDMAX,
    FVV_VFREDMIN,
    FVV_VFWREDOSUM,
    FVV_VFWREDUSUM
}

/// rivvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L94.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum rivvfunct6 {
    IVV_VWREDSUMU,
    IVV_VWREDSUM
}

/// rmvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L91-92.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum rmvvfunct6 {
    MVV_VREDSUM,
    MVV_VREDAND,
    MVV_VREDOR,
    MVV_VREDXOR,
    MVV_VREDMINU,
    MVV_VREDMIN,
    MVV_VREDMAXU,
    MVV_VREDMAX
}

/// rop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L274-275.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum rop {
    ADD,
    SUB,
    SLL,
    SLT,
    SLTU,
    XOR,
    SRL,
    SRA,
    OR,
    AND
}

/// ropw
/// 
/// Generated from the Sail sources at `riscv_types.sail` L277.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ropw {
    ADDW,
    SUBW,
    SLLW,
    SRLW,
    SRAW
}

/// sop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L273.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum sop {
    SLLI,
    SRLI,
    SRAI
}

/// sopw
/// 
/// Generated from the Sail sources at `riscv_types.sail` L278.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum sopw {
    SLLIW,
    SRLIW,
    SRAIW
}

/// word_width
/// 
/// Generated from the Sail sources at `riscv_types.sail` L93.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum word_width {
    BYTE,
    HALF,
    WORD,
    DOUBLE
}

/// uop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L270.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum uop {
    LUI,
    AUIPC
}

/// vext2funct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L69.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vext2funct6 {
    VEXT2_ZVF2,
    VEXT2_SVF2
}

/// vext4funct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L71.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vext4funct6 {
    VEXT4_ZVF4,
    VEXT4_SVF4
}

/// vext8funct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L73.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vext8funct6 {
    VEXT8_ZVF8,
    VEXT8_SVF8
}

/// vfnunary0
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L130-131.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vfnunary0 {
    FNV_CVT_XU_F,
    FNV_CVT_X_F,
    FNV_CVT_F_XU,
    FNV_CVT_F_X,
    FNV_CVT_F_F,
    FNV_CVT_ROD_F_F,
    FNV_CVT_RTZ_XU_F,
    FNV_CVT_RTZ_X_F
}

/// vfunary0
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L125.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vfunary0 {
    FV_CVT_XU_F,
    FV_CVT_X_F,
    FV_CVT_F_XU,
    FV_CVT_F_X,
    FV_CVT_RTZ_XU_F,
    FV_CVT_RTZ_X_F
}

/// vfunary1
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L133.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vfunary1 {
    FVV_VSQRT,
    FVV_VRSQRT7,
    FVV_VREC7,
    FVV_VCLASS
}

/// vfwunary0
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L127-128.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vfwunary0 {
    FWV_CVT_XU_F,
    FWV_CVT_X_F,
    FWV_CVT_F_XU,
    FWV_CVT_F_X,
    FWV_CVT_F_F,
    FWV_CVT_RTZ_XU_F,
    FWV_CVT_RTZ_X_F
}

/// vicmpfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L45.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vicmpfunct6 {
    VICMP_VMSEQ,
    VICMP_VMSNE,
    VICMP_VMSLEU,
    VICMP_VMSLE,
    VICMP_VMSGTU,
    VICMP_VMSGT
}

/// vimcfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L38.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vimcfunct6 {
    VIMC_VMADC
}

/// vimsfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L40.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vimsfunct6 {
    VIMS_VADC
}

/// vimfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L36.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vimfunct6 {
    VIM_VMADC
}

/// visgfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L84.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum visgfunct6 {
    VI_VSLIDEUP,
    VI_VSLIDEDOWN,
    VI_VRGATHER
}

/// vifunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L79-80.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vifunct6 {
    VI_VADD,
    VI_VRSUB,
    VI_VAND,
    VI_VOR,
    VI_VXOR,
    VI_VSADDU,
    VI_VSADD,
    VI_VSLL,
    VI_VSRL,
    VI_VSRA,
    VI_VSSRL,
    VI_VSSRA
}

/// vlewidth
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L110.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vlewidth {
    VLE8,
    VLE16,
    VLE32,
    VLE64
}

/// vmlsop
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L148.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vmlsop {
    VLM,
    VSM
}

/// vregidx
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L9.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vregidx {
    Vregidx(BitVector<5>)
}

/// zvkfunct6
/// 
/// Generated from the Sail sources at `riscv_zvk_utils.sail` L28.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum zvkfunct6 {
    ZVK_VSHA2CH,
    ZVK_VSHA2CL
}

/// vvcmpfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L22.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vvcmpfunct6 {
    VVCMP_VMSEQ,
    VVCMP_VMSNE,
    VVCMP_VMSLTU,
    VVCMP_VMSLT,
    VVCMP_VMSLEU,
    VVCMP_VMSLE
}

/// vvmcfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L26.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vvmcfunct6 {
    VVMC_VMADC,
    VVMC_VMSBC
}

/// vvmsfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L28.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vvmsfunct6 {
    VVMS_VADC,
    VVMS_VSBC
}

/// vvmfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L24.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vvmfunct6 {
    VVM_VMADC,
    VVM_VMSBC
}

/// vvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L18-20.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vvfunct6 {
    VV_VADD,
    VV_VSUB,
    VV_VMINU,
    VV_VMIN,
    VV_VMAXU,
    VV_VMAX,
    VV_VAND,
    VV_VOR,
    VV_VXOR,
    VV_VRGATHER,
    VV_VRGATHEREI16,
    VV_VSADDU,
    VV_VSADD,
    VV_VSSUBU,
    VV_VSSUB,
    VV_VSLL,
    VV_VSMUL,
    VV_VSRL,
    VV_VSRA,
    VV_VSSRL,
    VV_VSSRA
}

/// vxcmpfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L42-43.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxcmpfunct6 {
    VXCMP_VMSEQ,
    VXCMP_VMSNE,
    VXCMP_VMSLTU,
    VXCMP_VMSLT,
    VXCMP_VMSLEU,
    VXCMP_VMSLE,
    VXCMP_VMSGTU,
    VXCMP_VMSGT
}

/// vxmcfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L32.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxmcfunct6 {
    VXMC_VMADC,
    VXMC_VMSBC
}

/// vxmsfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L34.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxmsfunct6 {
    VXMS_VADC,
    VXMS_VSBC
}

/// vxmfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L30.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxmfunct6 {
    VXM_VMADC,
    VXM_VMSBC
}

/// vxsgfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L82.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxsgfunct6 {
    VX_VSLIDEUP,
    VX_VSLIDEDOWN,
    VX_VRGATHER
}

/// vxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L75-77.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vxfunct6 {
    VX_VADD,
    VX_VSUB,
    VX_VRSUB,
    VX_VMINU,
    VX_VMIN,
    VX_VMAXU,
    VX_VMAX,
    VX_VAND,
    VX_VOR,
    VX_VXOR,
    VX_VSADDU,
    VX_VSADD,
    VX_VSSUBU,
    VX_VSSUB,
    VX_VSLL,
    VX_VSMUL,
    VX_VSRL,
    VX_VSRA,
    VX_VSSRL,
    VX_VSSRA
}

/// wmvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L99.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wmvvfunct6 {
    WMVV_VWMACCU,
    WMVV_VWMACC,
    WMVV_VWMACCSU
}

/// wmvxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L106.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wmvxfunct6 {
    WMVX_VWMACCU,
    WMVX_VWMACC,
    WMVX_VWMACCUS,
    WMVX_VWMACCSU
}

/// wvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L63.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wvfunct6 {
    WV_VADD,
    WV_VSUB,
    WV_VADDU,
    WV_VSUBU
}

/// wvvfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L61.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wvvfunct6 {
    WVV_VADD,
    WVV_VSUB,
    WVV_VADDU,
    WVV_VSUBU,
    WVV_VWMUL,
    WVV_VWMULU,
    WVV_VWMULSU
}

/// wvxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L65.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wvxfunct6 {
    WVX_VADD,
    WVX_VSUB,
    WVX_VADDU,
    WVX_VSUBU,
    WVX_VWMUL,
    WVX_VWMULU,
    WVX_VWMULSU
}

/// wxfunct6
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L67.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum wxfunct6 {
    WX_VADD,
    WX_VSUB,
    WX_VADDU,
    WX_VSUBU
}

/// brop_zba
/// 
/// Generated from the Sail sources at `riscv_types.sail` L285.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum brop_zba {
    SH1ADD,
    SH2ADD,
    SH3ADD
}

/// bropw_zba
/// 
/// Generated from the Sail sources at `riscv_types.sail` L293.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum bropw_zba {
    ADDUW,
    SH1ADDUW,
    SH2ADDUW,
    SH3ADDUW
}

/// extop_zbb
/// 
/// Generated from the Sail sources at `riscv_types.sail` L299.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum extop_zbb {
    SEXTB,
    SEXTH,
    ZEXTH
}

/// brop_zbb
/// 
/// Generated from the Sail sources at `riscv_types.sail` L287.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum brop_zbb {
    ANDN,
    ORN,
    XNOR,
    MAX,
    MAXU,
    MIN,
    MINU,
    ROL,
    ROR
}

/// bropw_zbb
/// 
/// Generated from the Sail sources at `riscv_types.sail` L295.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum bropw_zbb {
    ROLW,
    RORW
}

/// brop_zbkb
/// 
/// Generated from the Sail sources at `riscv_types.sail` L289.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum brop_zbkb {
    PACK,
    PACKH
}

/// biop_zbs
/// 
/// Generated from the Sail sources at `riscv_types.sail` L297.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum biop_zbs {
    BCLRI,
    BEXTI,
    BINVI,
    BSETI
}

/// brop_zbs
/// 
/// Generated from the Sail sources at `riscv_types.sail` L291.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum brop_zbs {
    BCLR,
    BEXT,
    BINV,
    BSET
}

/// zicondop
/// 
/// Generated from the Sail sources at `riscv_types.sail` L301.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum zicondop {
    CZERO_EQZ,
    CZERO_NEZ
}

/// f_un_rm_ff_op_S
/// 
/// Generated from the Sail sources at `riscv_freg_type.sail` L62.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum f_un_rm_ff_op_S {
    FSQRT_S
}

/// ast
/// 
/// Generated from the Sail sources at `riscv_insts_begin.sail` L14.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ast {
    ILLEGAL(word),
    C_ILLEGAL(half),
    UTYPE((BitVector<20>, regidx, uop)),
    JAL((BitVector<21>, regidx)),
    JALR((BitVector<12>, regidx, regidx)),
    BTYPE((BitVector<13>, regidx, regidx, bop)),
    ITYPE((BitVector<12>, regidx, regidx, iop)),
    SHIFTIOP((BitVector<6>, regidx, regidx, sop)),
    RTYPE((regidx, regidx, regidx, rop)),
    LOAD((BitVector<12>, regidx, regidx, bool, word_width, bool, bool)),
    STORE((BitVector<12>, regidx, regidx, word_width, bool, bool)),
    ADDIW((BitVector<12>, regidx, regidx)),
    RTYPEW((regidx, regidx, regidx, ropw)),
    SHIFTIWOP((BitVector<5>, regidx, regidx, sopw)),
    FENCE((BitVector<4>, BitVector<4>)),
    FENCE_TSO((BitVector<4>, BitVector<4>)),
    ECALL(()),
    MRET(()),
    SRET(()),
    EBREAK(()),
    WFI(()),
    SFENCE_VMA((regidx, regidx)),
    FENCEI(()),
    LOADRES((bool, bool, regidx, word_width, regidx)),
    STORECON((bool, bool, regidx, regidx, word_width, regidx)),
    AMO((amoop, bool, bool, regidx, regidx, word_width, regidx)),
    C_NOP(()),
    C_ADDI4SPN((cregidx, BitVector<8>)),
    C_LW((BitVector<5>, cregidx, cregidx)),
    C_LD((BitVector<5>, cregidx, cregidx)),
    C_SW((BitVector<5>, cregidx, cregidx)),
    C_SD((BitVector<5>, cregidx, cregidx)),
    C_ADDI((BitVector<6>, regidx)),
    C_JAL(BitVector<11>),
    C_ADDIW((BitVector<6>, regidx)),
    C_LI((BitVector<6>, regidx)),
    C_ADDI16SP(BitVector<6>),
    C_LUI((BitVector<6>, regidx)),
    C_SRLI((BitVector<6>, cregidx)),
    C_SRAI((BitVector<6>, cregidx)),
    C_ANDI((BitVector<6>, cregidx)),
    C_SUB((cregidx, cregidx)),
    C_XOR((cregidx, cregidx)),
    C_OR((cregidx, cregidx)),
    C_AND((cregidx, cregidx)),
    C_SUBW((cregidx, cregidx)),
    C_ADDW((cregidx, cregidx)),
    C_J(BitVector<11>),
    C_BEQZ((BitVector<8>, cregidx)),
    C_BNEZ((BitVector<8>, cregidx)),
    C_SLLI((BitVector<6>, regidx)),
    C_LWSP((BitVector<6>, regidx)),
    C_LDSP((BitVector<6>, regidx)),
    C_SWSP((BitVector<6>, regidx)),
    C_SDSP((BitVector<6>, regidx)),
    C_JR(regidx),
    C_JALR(regidx),
    C_MV((regidx, regidx)),
    C_EBREAK(()),
    C_ADD((regidx, regidx)),
    MUL((regidx, regidx, regidx, mul_op)),
    DIV((regidx, regidx, regidx, bool)),
    REM((regidx, regidx, regidx, bool)),
    MULW((regidx, regidx, regidx)),
    DIVW((regidx, regidx, regidx, bool)),
    REMW((regidx, regidx, regidx, bool)),
    CSRReg((csreg, regidx, regidx, csrop)),
    CSRImm((csreg, BitVector<5>, regidx, csrop)),
    C_NOP_HINT(BitVector<6>),
    C_ADDI_HINT(regidx),
    C_LI_HINT(BitVector<6>),
    C_LUI_HINT(BitVector<6>),
    C_MV_HINT(regidx),
    C_ADD_HINT(regidx),
    C_SLLI_HINT((BitVector<6>, regidx)),
    C_SRLI_HINT(cregidx),
    C_SRAI_HINT(cregidx),
    FENCE_RESERVED((BitVector<4>, BitVector<4>, BitVector<4>, regidx, regidx)),
    FENCEI_RESERVED((BitVector<12>, regidx, regidx)),
    LOAD_FP((BitVector<12>, regidx, fregidx, word_width)),
    STORE_FP((BitVector<12>, fregidx, regidx, word_width)),
    F_MADD_TYPE_S((fregidx, fregidx, fregidx, rounding_mode, fregidx, f_madd_op_S)),
    F_BIN_RM_TYPE_S((fregidx, fregidx, rounding_mode, fregidx, f_bin_rm_op_S)),
    F_UN_RM_FF_TYPE_S((fregidx, rounding_mode, fregidx, f_un_rm_ff_op_S)),
    F_UN_RM_FX_TYPE_S((fregidx, rounding_mode, regidx, f_un_rm_fx_op_S)),
    F_UN_RM_XF_TYPE_S((regidx, rounding_mode, fregidx, f_un_rm_xf_op_S)),
    F_BIN_TYPE_F_S((fregidx, fregidx, fregidx, f_bin_op_f_S)),
    F_BIN_TYPE_X_S((fregidx, fregidx, regidx, f_bin_op_x_S)),
    F_UN_TYPE_F_S((regidx, fregidx, f_un_op_f_S)),
    F_UN_TYPE_X_S((fregidx, regidx, f_un_op_x_S)),
    C_FLWSP((BitVector<6>, fregidx)),
    C_FSWSP((BitVector<6>, fregidx)),
    C_FLW((BitVector<5>, cregidx, cregidx)),
    C_FSW((BitVector<5>, cregidx, cregidx)),
    F_MADD_TYPE_D((fregidx, fregidx, fregidx, rounding_mode, fregidx, f_madd_op_D)),
    F_BIN_RM_TYPE_D((fregidx, fregidx, rounding_mode, fregidx, f_bin_rm_op_D)),
    F_UN_RM_FF_TYPE_D((fregidx, rounding_mode, fregidx, f_un_rm_ff_op_D)),
    F_UN_RM_XF_TYPE_D((regidx, rounding_mode, fregidx, f_un_rm_xf_op_D)),
    F_UN_RM_FX_TYPE_D((fregidx, rounding_mode, regidx, f_un_rm_fx_op_D)),
    F_BIN_F_TYPE_D((fregidx, fregidx, fregidx, f_bin_f_op_D)),
    F_BIN_X_TYPE_D((fregidx, fregidx, regidx, f_bin_x_op_D)),
    F_UN_X_TYPE_D((fregidx, regidx, f_un_x_op_D)),
    F_UN_F_TYPE_D((regidx, fregidx, f_un_f_op_D)),
    C_FLDSP((BitVector<6>, fregidx)),
    C_FSDSP((BitVector<6>, fregidx)),
    C_FLD((BitVector<5>, cregidx, cregidx)),
    C_FSD((BitVector<5>, cregidx, cregidx)),
    SINVAL_VMA((regidx, regidx)),
    SFENCE_W_INVAL(()),
    SFENCE_INVAL_IR(()),
    SLLIUW((BitVector<6>, regidx, regidx)),
    ZBA_RTYPEUW((regidx, regidx, regidx, bropw_zba)),
    ZBA_RTYPE((regidx, regidx, regidx, brop_zba)),
    RORIW((BitVector<5>, regidx, regidx)),
    RORI((BitVector<6>, regidx, regidx)),
    ZBB_RTYPEW((regidx, regidx, regidx, bropw_zbb)),
    ZBB_RTYPE((regidx, regidx, regidx, brop_zbb)),
    ZBB_EXTOP((regidx, regidx, extop_zbb)),
    REV8((regidx, regidx)),
    ORCB((regidx, regidx)),
    CPOP((regidx, regidx)),
    CPOPW((regidx, regidx)),
    CLZ((regidx, regidx)),
    CLZW((regidx, regidx)),
    CTZ((regidx, regidx)),
    CTZW((regidx, regidx)),
    CLMUL((regidx, regidx, regidx)),
    CLMULH((regidx, regidx, regidx)),
    CLMULR((regidx, regidx, regidx)),
    ZBS_IOP((BitVector<6>, regidx, regidx, biop_zbs)),
    ZBS_RTYPE((regidx, regidx, regidx, brop_zbs)),
    C_LBU((BitVector<2>, cregidx, cregidx)),
    C_LHU((BitVector<2>, cregidx, cregidx)),
    C_LH((BitVector<2>, cregidx, cregidx)),
    C_SB((BitVector<2>, cregidx, cregidx)),
    C_SH((BitVector<2>, cregidx, cregidx)),
    C_ZEXT_B(cregidx),
    C_SEXT_B(cregidx),
    C_ZEXT_H(cregidx),
    C_SEXT_H(cregidx),
    C_ZEXT_W(cregidx),
    C_NOT(cregidx),
    C_MUL((cregidx, cregidx)),
    F_BIN_RM_TYPE_H((fregidx, fregidx, rounding_mode, fregidx, f_bin_rm_op_H)),
    F_MADD_TYPE_H((fregidx, fregidx, fregidx, rounding_mode, fregidx, f_madd_op_H)),
    F_BIN_F_TYPE_H((fregidx, fregidx, fregidx, f_bin_f_op_H)),
    F_BIN_X_TYPE_H((fregidx, fregidx, regidx, f_bin_x_op_H)),
    F_UN_RM_FF_TYPE_H((fregidx, rounding_mode, fregidx, f_un_rm_ff_op_H)),
    F_UN_RM_FX_TYPE_H((fregidx, rounding_mode, regidx, f_un_rm_fx_op_H)),
    F_UN_RM_XF_TYPE_H((regidx, rounding_mode, fregidx, f_un_rm_xf_op_H)),
    F_UN_F_TYPE_H((regidx, fregidx, f_un_f_op_H)),
    F_UN_X_TYPE_H((fregidx, regidx, f_un_x_op_H)),
    FLI_H((BitVector<5>, fregidx)),
    FLI_S((BitVector<5>, fregidx)),
    FLI_D((BitVector<5>, fregidx)),
    FMINM_H((fregidx, fregidx, fregidx)),
    FMAXM_H((fregidx, fregidx, fregidx)),
    FMINM_S((fregidx, fregidx, fregidx)),
    FMAXM_S((fregidx, fregidx, fregidx)),
    FMINM_D((fregidx, fregidx, fregidx)),
    FMAXM_D((fregidx, fregidx, fregidx)),
    FROUND_H((fregidx, rounding_mode, fregidx)),
    FROUNDNX_H((fregidx, rounding_mode, fregidx)),
    FROUND_S((fregidx, rounding_mode, fregidx)),
    FROUNDNX_S((fregidx, rounding_mode, fregidx)),
    FROUND_D((fregidx, rounding_mode, fregidx)),
    FROUNDNX_D((fregidx, rounding_mode, fregidx)),
    FMVH_X_D((fregidx, regidx)),
    FMVP_D_X((regidx, regidx, fregidx)),
    FLEQ_H((fregidx, fregidx, regidx)),
    FLTQ_H((fregidx, fregidx, regidx)),
    FLEQ_S((fregidx, fregidx, regidx)),
    FLTQ_S((fregidx, fregidx, regidx)),
    FLEQ_D((fregidx, fregidx, regidx)),
    FLTQ_D((fregidx, fregidx, regidx)),
    FCVTMOD_W_D((fregidx, regidx)),
    SHA256SIG0((regidx, regidx)),
    SHA256SIG1((regidx, regidx)),
    SHA256SUM0((regidx, regidx)),
    SHA256SUM1((regidx, regidx)),
    AES32ESMI((BitVector<2>, regidx, regidx, regidx)),
    AES32ESI((BitVector<2>, regidx, regidx, regidx)),
    AES32DSMI((BitVector<2>, regidx, regidx, regidx)),
    AES32DSI((BitVector<2>, regidx, regidx, regidx)),
    SHA512SIG0L((regidx, regidx, regidx)),
    SHA512SIG0H((regidx, regidx, regidx)),
    SHA512SIG1L((regidx, regidx, regidx)),
    SHA512SIG1H((regidx, regidx, regidx)),
    SHA512SUM0R((regidx, regidx, regidx)),
    SHA512SUM1R((regidx, regidx, regidx)),
    AES64KS1I((BitVector<4>, regidx, regidx)),
    AES64KS2((regidx, regidx, regidx)),
    AES64IM((regidx, regidx)),
    AES64ESM((regidx, regidx, regidx)),
    AES64ES((regidx, regidx, regidx)),
    AES64DSM((regidx, regidx, regidx)),
    AES64DS((regidx, regidx, regidx)),
    SHA512SIG0((regidx, regidx)),
    SHA512SIG1((regidx, regidx)),
    SHA512SUM0((regidx, regidx)),
    SHA512SUM1((regidx, regidx)),
    SM3P0((regidx, regidx)),
    SM3P1((regidx, regidx)),
    SM4ED((BitVector<2>, regidx, regidx, regidx)),
    SM4KS((BitVector<2>, regidx, regidx, regidx)),
    ZBKB_RTYPE((regidx, regidx, regidx, brop_zbkb)),
    ZBKB_PACKW((regidx, regidx, regidx)),
    ZIP((regidx, regidx)),
    UNZIP((regidx, regidx)),
    BREV8((regidx, regidx)),
    XPERM8((regidx, regidx, regidx)),
    XPERM4((regidx, regidx, regidx)),
    ZICOND_RTYPE((regidx, regidx, regidx, zicondop)),
    VSETVLI((BitVector<1>, BitVector<1>, BitVector<3>, BitVector<3>, regidx, regidx)),
    VSETVL((regidx, regidx, regidx)),
    VSETIVLI((BitVector<1>, BitVector<1>, BitVector<3>, BitVector<3>, BitVector<5>, regidx)),
    VVTYPE((vvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    NVSTYPE((nvsfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    NVTYPE((nvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    MASKTYPEV((vregidx, vregidx, vregidx)),
    MOVETYPEV((vregidx, vregidx)),
    VXTYPE((vxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    NXSTYPE((nxsfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    NXTYPE((nxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    VXSG((vxsgfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    MASKTYPEX((vregidx, regidx, vregidx)),
    MOVETYPEX((regidx, vregidx)),
    VITYPE((vifunct6, BitVector<1>, vregidx, BitVector<5>, vregidx)),
    NISTYPE((nisfunct6, BitVector<1>, vregidx, BitVector<5>, vregidx)),
    NITYPE((nifunct6, BitVector<1>, vregidx, BitVector<5>, vregidx)),
    VISG((visgfunct6, BitVector<1>, vregidx, BitVector<5>, vregidx)),
    MASKTYPEI((vregidx, BitVector<5>, vregidx)),
    MOVETYPEI((vregidx, BitVector<5>)),
    VMVRTYPE((vregidx, BitVector<5>, vregidx)),
    MVVTYPE((mvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    MVVMATYPE((mvvmafunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    WVVTYPE((wvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    WVTYPE((wvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    WMVVTYPE((wmvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    VEXT2TYPE((vext2funct6, BitVector<1>, vregidx, vregidx)),
    VEXT4TYPE((vext4funct6, BitVector<1>, vregidx, vregidx)),
    VEXT8TYPE((vext8funct6, BitVector<1>, vregidx, vregidx)),
    VMVXS((vregidx, regidx)),
    MVVCOMPRESS((vregidx, vregidx, vregidx)),
    MVXTYPE((mvxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    MVXMATYPE((mvxmafunct6, BitVector<1>, vregidx, regidx, vregidx)),
    WVXTYPE((wvxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    WXTYPE((wxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    WMVXTYPE((wmvxfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    VMVSX((regidx, vregidx)),
    FVVTYPE((fvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    FVVMATYPE((fvvmafunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    FWVVTYPE((fwvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    FWVVMATYPE((fwvvmafunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    FWVTYPE((fwvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    VFUNARY0((BitVector<1>, vregidx, vfunary0, vregidx)),
    VFWUNARY0((BitVector<1>, vregidx, vfwunary0, vregidx)),
    VFNUNARY0((BitVector<1>, vregidx, vfnunary0, vregidx)),
    VFUNARY1((BitVector<1>, vregidx, vfunary1, vregidx)),
    VFMVFS((vregidx, fregidx)),
    FVFTYPE((fvffunct6, BitVector<1>, vregidx, fregidx, vregidx)),
    FVFMATYPE((fvfmafunct6, BitVector<1>, vregidx, fregidx, vregidx)),
    FWVFTYPE((fwvffunct6, BitVector<1>, vregidx, fregidx, vregidx)),
    FWVFMATYPE((fwvfmafunct6, BitVector<1>, fregidx, vregidx, vregidx)),
    FWFTYPE((fwffunct6, BitVector<1>, vregidx, fregidx, vregidx)),
    VFMERGE((vregidx, fregidx, vregidx)),
    VFMV((fregidx, vregidx)),
    VFMVSF((fregidx, vregidx)),
    VLSEGTYPE((BitVector<3>, BitVector<1>, regidx, vlewidth, vregidx)),
    VLSEGFFTYPE((BitVector<3>, BitVector<1>, regidx, vlewidth, vregidx)),
    VSSEGTYPE((BitVector<3>, BitVector<1>, regidx, vlewidth, vregidx)),
    VLSSEGTYPE((BitVector<3>, BitVector<1>, regidx, regidx, vlewidth, vregidx)),
    VSSSEGTYPE((BitVector<3>, BitVector<1>, regidx, regidx, vlewidth, vregidx)),
    VLUXSEGTYPE((BitVector<3>, BitVector<1>, vregidx, regidx, vlewidth, vregidx)),
    VLOXSEGTYPE((BitVector<3>, BitVector<1>, vregidx, regidx, vlewidth, vregidx)),
    VSUXSEGTYPE((BitVector<3>, BitVector<1>, vregidx, regidx, vlewidth, vregidx)),
    VSOXSEGTYPE((BitVector<3>, BitVector<1>, vregidx, regidx, vlewidth, vregidx)),
    VLRETYPE((BitVector<3>, regidx, vlewidth, vregidx)),
    VSRETYPE((BitVector<3>, regidx, vregidx)),
    VMTYPE((regidx, vregidx, vmlsop)),
    MMTYPE((mmfunct6, vregidx, vregidx, vregidx)),
    VCPOP_M((BitVector<1>, vregidx, regidx)),
    VFIRST_M((BitVector<1>, vregidx, regidx)),
    VMSBF_M((BitVector<1>, vregidx, vregidx)),
    VMSIF_M((BitVector<1>, vregidx, vregidx)),
    VMSOF_M((BitVector<1>, vregidx, vregidx)),
    VIOTA_M((BitVector<1>, vregidx, vregidx)),
    VID_V((BitVector<1>, vregidx)),
    VVMTYPE((vvmfunct6, vregidx, vregidx, vregidx)),
    VVMCTYPE((vvmcfunct6, vregidx, vregidx, vregidx)),
    VVMSTYPE((vvmsfunct6, vregidx, vregidx, vregidx)),
    VVCMPTYPE((vvcmpfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    VXMTYPE((vxmfunct6, vregidx, regidx, vregidx)),
    VXMCTYPE((vxmcfunct6, vregidx, regidx, vregidx)),
    VXMSTYPE((vxmsfunct6, vregidx, regidx, vregidx)),
    VXCMPTYPE((vxcmpfunct6, BitVector<1>, vregidx, regidx, vregidx)),
    VIMTYPE((vimfunct6, vregidx, BitVector<5>, vregidx)),
    VIMCTYPE((vimcfunct6, vregidx, BitVector<5>, vregidx)),
    VIMSTYPE((vimsfunct6, vregidx, BitVector<5>, vregidx)),
    VICMPTYPE((vicmpfunct6, BitVector<1>, vregidx, BitVector<5>, vregidx)),
    FVVMTYPE((fvvmfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    FVFMTYPE((fvfmfunct6, BitVector<1>, vregidx, fregidx, vregidx)),
    RIVVTYPE((rivvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    RMVVTYPE((rmvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    RFVVTYPE((rfvvfunct6, BitVector<1>, vregidx, vregidx, vregidx)),
    ZICBOM((cbop_zicbom, regidx)),
    ZICBOZ(regidx),
    VANDN_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VANDN_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VBREV_V((BitVector<1>, vregidx, vregidx)),
    VBREV8_V((BitVector<1>, vregidx, vregidx)),
    VREV8_V((BitVector<1>, vregidx, vregidx)),
    VCLZ_V((BitVector<1>, vregidx, vregidx)),
    VCTZ_V((BitVector<1>, vregidx, vregidx)),
    VCPOP_V((BitVector<1>, vregidx, vregidx)),
    VROL_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VROL_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VROR_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VROR_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VROR_VI((BitVector<1>, vregidx, BitVector<5>, vregidx)),
    VWSLL_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VWSLL_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VWSLL_VI((BitVector<1>, vregidx, BitVector<5>, vregidx)),
    VCLMUL_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VCLMUL_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VCLMULH_VV((BitVector<1>, vregidx, vregidx, vregidx)),
    VCLMULH_VX((BitVector<1>, vregidx, regidx, vregidx)),
    VSHA2MS_VV((vregidx, vregidx, vregidx)),
    ZVKSHA2TYPE((zvkfunct6, vregidx, vregidx, vregidx)),
    VSM3ME_VV((vregidx, vregidx, vregidx)),
    VSM3C_VI((vregidx, BitVector<5>, vregidx)),
    ZIMOP_MOP_R((BitVector<5>, regidx, regidx)),
    ZIMOP_MOP_RR((BitVector<3>, regidx, regidx, regidx)),
    ZCMOP(BitVector<3>)
}

/// PTW_Error
/// 
/// Generated from the Sail sources at `riscv_vmem_ptw.sail` L17-25.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum PTW_Error {
    PTW_Invalid_Addr(()),
    PTW_Access(()),
    PTW_Invalid_PTE(()),
    PTW_No_Permission(()),
    PTW_Misaligned(()),
    PTW_PTE_Update(()),
    PTW_Ext_Error(ext_ptw_error)
}

/// InterruptType
/// 
/// Generated from the Sail sources at `riscv_types.sail` L97-107.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum InterruptType {
    I_U_Software,
    I_S_Software,
    I_M_Software,
    I_U_Timer,
    I_S_Timer,
    I_M_Timer,
    I_U_External,
    I_S_External,
    I_M_External
}

/// interruptType_to_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L110-121.
pub fn interruptType_to_bits(i: InterruptType) -> BitVector<8> {
    match i {
        InterruptType::I_U_Software => {BitVector::<8>::new(0b00000000)}
        InterruptType::I_S_Software => {BitVector::<8>::new(0b00000001)}
        InterruptType::I_M_Software => {BitVector::<8>::new(0b00000011)}
        InterruptType::I_U_Timer => {BitVector::<8>::new(0b00000100)}
        InterruptType::I_S_Timer => {BitVector::<8>::new(0b00000101)}
        InterruptType::I_M_Timer => {BitVector::<8>::new(0b00000111)}
        InterruptType::I_U_External => {BitVector::<8>::new(0b00001000)}
        InterruptType::I_S_External => {BitVector::<8>::new(0b00001001)}
        InterruptType::I_M_External => {BitVector::<8>::new(0b00001011)}
        _ => {panic!("Unreachable code")}
    }
}

/// exceptionType_to_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L148-169.
pub fn exceptionType_to_bits(e: ExceptionType) -> BitVector<8> {
    match e {
        ExceptionType::E_Fetch_Addr_Align(()) => {BitVector::<8>::new(0b00000000)}
        ExceptionType::E_Fetch_Access_Fault(()) => {BitVector::<8>::new(0b00000001)}
        ExceptionType::E_Illegal_Instr(()) => {BitVector::<8>::new(0b00000010)}
        ExceptionType::E_Breakpoint(()) => {BitVector::<8>::new(0b00000011)}
        ExceptionType::E_Load_Addr_Align(()) => {BitVector::<8>::new(0b00000100)}
        ExceptionType::E_Load_Access_Fault(()) => {BitVector::<8>::new(0b00000101)}
        ExceptionType::E_SAMO_Addr_Align(()) => {BitVector::<8>::new(0b00000110)}
        ExceptionType::E_SAMO_Access_Fault(()) => {BitVector::<8>::new(0b00000111)}
        ExceptionType::E_U_EnvCall(()) => {BitVector::<8>::new(0b00001000)}
        ExceptionType::E_S_EnvCall(()) => {BitVector::<8>::new(0b00001001)}
        ExceptionType::E_Reserved_10(()) => {BitVector::<8>::new(0b00001010)}
        ExceptionType::E_M_EnvCall(()) => {BitVector::<8>::new(0b00001011)}
        ExceptionType::E_Fetch_Page_Fault(()) => {BitVector::<8>::new(0b00001100)}
        ExceptionType::E_Load_Page_Fault(()) => {BitVector::<8>::new(0b00001101)}
        ExceptionType::E_Reserved_14(()) => {BitVector::<8>::new(0b00001110)}
        ExceptionType::E_SAMO_Page_Fault(()) => {BitVector::<8>::new(0b00001111)}
        ExceptionType::E_Extension(e) => {ext_exc_type_to_bits(e)}
        _ => {panic!("Unreachable code")}
    }
}

/// num_of_ExceptionType
/// 
/// Generated from the Sail sources at `riscv_types.sail` L172-194.
pub fn num_of_ExceptionType(e: ExceptionType) -> i128 {
    match e {
        ExceptionType::E_Fetch_Addr_Align(()) => {0}
        ExceptionType::E_Fetch_Access_Fault(()) => {1}
        ExceptionType::E_Illegal_Instr(()) => {2}
        ExceptionType::E_Breakpoint(()) => {3}
        ExceptionType::E_Load_Addr_Align(()) => {4}
        ExceptionType::E_Load_Access_Fault(()) => {5}
        ExceptionType::E_SAMO_Addr_Align(()) => {6}
        ExceptionType::E_SAMO_Access_Fault(()) => {7}
        ExceptionType::E_U_EnvCall(()) => {8}
        ExceptionType::E_S_EnvCall(()) => {9}
        ExceptionType::E_Reserved_10(()) => {10}
        ExceptionType::E_M_EnvCall(()) => {11}
        ExceptionType::E_Fetch_Page_Fault(()) => {12}
        ExceptionType::E_Load_Page_Fault(()) => {13}
        ExceptionType::E_Reserved_14(()) => {14}
        ExceptionType::E_SAMO_Page_Fault(()) => {15}
        ExceptionType::E_Extension(e) => {24}
        _ => {panic!("Unreachable code")}
    }
}

pub type tv_mode = BitVector<2>;

/// TrapVectorMode
/// 
/// Generated from the Sail sources at `riscv_types.sail` L225.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum TrapVectorMode {
    TV_Direct,
    TV_Vector,
    TV_Reserved
}

/// trapVectorMode_of_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L228-233.
pub fn trapVectorMode_of_bits(m: BitVector<2>) -> TrapVectorMode {
    match m {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {TrapVectorMode::TV_Direct}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {TrapVectorMode::TV_Vector}
        _ => {TrapVectorMode::TV_Reserved}
        _ => {panic!("Unreachable code")}
    }
}

pub type ext_status = BitVector<2>;

/// ExtStatus
/// 
/// Generated from the Sail sources at `riscv_types.sail` L238.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ExtStatus {
    Off,
    Initial,
    Clean,
    Dirty
}

/// extStatus_bits_forwards
/// 
/// Generated from the Sail sources.
pub fn extStatus_bits_forwards(arg_hashtag_: ExtStatus) -> BitVector<2> {
    match arg_hashtag_ {
        ExtStatus::Off => {BitVector::<2>::new(0b00)}
        ExtStatus::Initial => {BitVector::<2>::new(0b01)}
        ExtStatus::Clean => {BitVector::<2>::new(0b10)}
        ExtStatus::Dirty => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// extStatus_bits_backwards
/// 
/// Generated from the Sail sources.
pub fn extStatus_bits_backwards(arg_hashtag_: BitVector<2>) -> ExtStatus {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {ExtStatus::Off}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {ExtStatus::Initial}
        b__2 if {(b__2 == BitVector::<2>::new(0b10))} => {ExtStatus::Clean}
        _ => {ExtStatus::Dirty}
        _ => {panic!("Unreachable code")}
    }
}

/// extStatus_to_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L247.
pub fn extStatus_to_bits(e: ExtStatus) -> BitVector<2> {
    extStatus_bits_forwards(e)
}

/// extStatus_of_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L248.
pub fn extStatus_of_bits(b: BitVector<2>) -> ExtStatus {
    extStatus_bits_backwards(b)
}

pub type satp_mode = BitVector<4>;

/// SATPMode
/// 
/// Generated from the Sail sources at `riscv_types.sail` L253.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum SATPMode {
    Bare,
    Sv32,
    Sv39,
    Sv48,
    Sv57
}

/// satpMode_of_bits
/// 
/// Generated from the Sail sources at `riscv_types.sail` L255-263.
pub fn satpMode_of_bits(a: Architecture, m: BitVector<4>) -> Option<SATPMode> {
    match (a, m) {
        (_, b__0) if {(b__0 == BitVector::<4>::new(0b0000))} => {Some(SATPMode::Bare)}
        (Architecture::RV32, b__1) if {(b__1 == BitVector::<4>::new(0b0001))} => {Some(SATPMode::Sv32)}
        (Architecture::RV64, b__2) if {(b__2 == BitVector::<4>::new(0b1000))} => {Some(SATPMode::Sv39)}
        (Architecture::RV64, b__3) if {(b__3 == BitVector::<4>::new(0b1001))} => {Some(SATPMode::Sv48)}
        (Architecture::RV64, b__4) if {(b__4 == BitVector::<4>::new(0b1010))} => {Some(SATPMode::Sv57)}
        (_, _) => {None}
        _ => {panic!("Unreachable code")}
    }
}

pub type csrRW = BitVector<2>;

/// size_enc_backwards
/// 
/// Generated from the Sail sources.
pub fn size_enc_backwards(arg_hashtag_: BitVector<2>) -> word_width {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {word_width::BYTE}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {word_width::HALF}
        b__2 if {(b__2 == BitVector::<2>::new(0b10))} => {word_width::WORD}
        _ => {word_width::DOUBLE}
        _ => {panic!("Unreachable code")}
    }
}

/// size_enc_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn size_enc_backwards_matches(arg_hashtag_: BitVector<2>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {true}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {true}
        b__2 if {(b__2 == BitVector::<2>::new(0b10))} => {true}
        b__3 if {(b__3 == BitVector::<2>::new(0b11))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// size_bytes_forwards
/// 
/// Generated from the Sail sources.
pub fn size_bytes_forwards(arg_hashtag_: word_width) -> i128 {
    match arg_hashtag_ {
        word_width::BYTE => {1}
        word_width::HALF => {2}
        word_width::WORD => {4}
        word_width::DOUBLE => {8}
        _ => {panic!("Unreachable code")}
    }
}

pub type level_range<const V: i128> = i128;

pub type ext_access_type = ();

pub const Data: ext_access_type = ();

pub const default_write_acc: ext_access_type = Data;

/// xreg_write_callback
/// 
/// Generated from the Sail sources at `riscv_callbacks.sail` L23.
pub const fn xreg_write_callback(_: regidx, missing_arg_0: BitVector<{
    64
}>) {
    ()
}

/// csr_full_read_callback
/// 
/// Generated from the Sail sources at `riscv_callbacks.sail` L29.
pub const fn csr_full_read_callback(_: &'static str, missing_arg_0: BitVector<12>, missing_arg_1: BitVector<{
    64
}>) {
    ()
}

/// trap_callback
/// 
/// Generated from the Sail sources at `riscv_callbacks.sail` L32.
pub const fn trap_callback(unit_arg: ()) {
    ()
}

/// csr_name_map_backwards
/// 
/// Generated from the Sail sources.
pub fn csr_name_map_backwards(arg_hashtag_: &'static str) -> BitVector<12> {
    let head_exp_hashtag_ = arg_hashtag_;
    match match head_exp_hashtag_ {
        "misa" => {Some(BitVector::<12>::new(0b001100000001))}
        "mstatus" => {Some(BitVector::<12>::new(0b001100000000))}
        "menvcfg" => {Some(BitVector::<12>::new(0b001100001010))}
        "menvcfgh" => {Some(BitVector::<12>::new(0b001100011010))}
        "senvcfg" => {Some(BitVector::<12>::new(0b000100001010))}
        "mie" => {Some(BitVector::<12>::new(0b001100000100))}
        "mip" => {Some(BitVector::<12>::new(0b001101000100))}
        "medeleg" => {Some(BitVector::<12>::new(0b001100000010))}
        "medelegh" => {Some(BitVector::<12>::new(0b001100010010))}
        "mideleg" => {Some(BitVector::<12>::new(0b001100000011))}
        "mcause" => {Some(BitVector::<12>::new(0b001101000010))}
        "mtval" => {Some(BitVector::<12>::new(0b001101000011))}
        "mscratch" => {Some(BitVector::<12>::new(0b001101000000))}
        "scounteren" => {Some(BitVector::<12>::new(0b000100000110))}
        "mcounteren" => {Some(BitVector::<12>::new(0b001100000110))}
        "mcountinhibit" => {Some(BitVector::<12>::new(0b001100100000))}
        "mvendorid" => {Some(BitVector::<12>::new(0b111100010001))}
        "marchid" => {Some(BitVector::<12>::new(0b111100010010))}
        "mimpid" => {Some(BitVector::<12>::new(0b111100010011))}
        "mhartid" => {Some(BitVector::<12>::new(0b111100010100))}
        "mconfigptr" => {Some(BitVector::<12>::new(0b111100010101))}
        "sstatus" => {Some(BitVector::<12>::new(0b000100000000))}
        "sip" => {Some(BitVector::<12>::new(0b000101000100))}
        "sie" => {Some(BitVector::<12>::new(0b000100000100))}
        "sscratch" => {Some(BitVector::<12>::new(0b000101000000))}
        "scause" => {Some(BitVector::<12>::new(0b000101000010))}
        "stval" => {Some(BitVector::<12>::new(0b000101000011))}
        "tselect" => {Some(BitVector::<12>::new(0b011110100000))}
        "tdata1" => {Some(BitVector::<12>::new(0b011110100001))}
        "tdata2" => {Some(BitVector::<12>::new(0b011110100010))}
        "tdata3" => {Some(BitVector::<12>::new(0b011110100011))}
        "pmpcfg0" => {Some(BitVector::<12>::new(0b001110100000))}
        "pmpcfg1" => {Some(BitVector::<12>::new(0b001110100001))}
        "pmpcfg2" => {Some(BitVector::<12>::new(0b001110100010))}
        "pmpcfg3" => {Some(BitVector::<12>::new(0b001110100011))}
        "pmpcfg4" => {Some(BitVector::<12>::new(0b001110100100))}
        "pmpcfg5" => {Some(BitVector::<12>::new(0b001110100101))}
        "pmpcfg6" => {Some(BitVector::<12>::new(0b001110100110))}
        "pmpcfg7" => {Some(BitVector::<12>::new(0b001110100111))}
        "pmpcfg8" => {Some(BitVector::<12>::new(0b001110101000))}
        "pmpcfg9" => {Some(BitVector::<12>::new(0b001110101001))}
        "pmpcfg10" => {Some(BitVector::<12>::new(0b001110101010))}
        "pmpcfg11" => {Some(BitVector::<12>::new(0b001110101011))}
        "pmpcfg12" => {Some(BitVector::<12>::new(0b001110101100))}
        "pmpcfg13" => {Some(BitVector::<12>::new(0b001110101101))}
        "pmpcfg14" => {Some(BitVector::<12>::new(0b001110101110))}
        "pmpcfg15" => {Some(BitVector::<12>::new(0b001110101111))}
        "pmpaddr0" => {Some(BitVector::<12>::new(0b001110110000))}
        "pmpaddr1" => {Some(BitVector::<12>::new(0b001110110001))}
        "pmpaddr2" => {Some(BitVector::<12>::new(0b001110110010))}
        "pmpaddr3" => {Some(BitVector::<12>::new(0b001110110011))}
        "pmpaddr4" => {Some(BitVector::<12>::new(0b001110110100))}
        "pmpaddr5" => {Some(BitVector::<12>::new(0b001110110101))}
        "pmpaddr6" => {Some(BitVector::<12>::new(0b001110110110))}
        "pmpaddr7" => {Some(BitVector::<12>::new(0b001110110111))}
        "pmpaddr8" => {Some(BitVector::<12>::new(0b001110111000))}
        "pmpaddr9" => {Some(BitVector::<12>::new(0b001110111001))}
        "pmpaddr10" => {Some(BitVector::<12>::new(0b001110111010))}
        "pmpaddr11" => {Some(BitVector::<12>::new(0b001110111011))}
        "pmpaddr12" => {Some(BitVector::<12>::new(0b001110111100))}
        "pmpaddr13" => {Some(BitVector::<12>::new(0b001110111101))}
        "pmpaddr14" => {Some(BitVector::<12>::new(0b001110111110))}
        "pmpaddr15" => {Some(BitVector::<12>::new(0b001110111111))}
        "pmpaddr16" => {Some(BitVector::<12>::new(0b001111000000))}
        "pmpaddr17" => {Some(BitVector::<12>::new(0b001111000001))}
        "pmpaddr18" => {Some(BitVector::<12>::new(0b001111000010))}
        "pmpaddr19" => {Some(BitVector::<12>::new(0b001111000011))}
        "pmpaddr20" => {Some(BitVector::<12>::new(0b001111000100))}
        "pmpaddr21" => {Some(BitVector::<12>::new(0b001111000101))}
        "pmpaddr22" => {Some(BitVector::<12>::new(0b001111000110))}
        "pmpaddr23" => {Some(BitVector::<12>::new(0b001111000111))}
        "pmpaddr24" => {Some(BitVector::<12>::new(0b001111001000))}
        "pmpaddr25" => {Some(BitVector::<12>::new(0b001111001001))}
        "pmpaddr26" => {Some(BitVector::<12>::new(0b001111001010))}
        "pmpaddr27" => {Some(BitVector::<12>::new(0b001111001011))}
        "pmpaddr28" => {Some(BitVector::<12>::new(0b001111001100))}
        "pmpaddr29" => {Some(BitVector::<12>::new(0b001111001101))}
        "pmpaddr30" => {Some(BitVector::<12>::new(0b001111001110))}
        "pmpaddr31" => {Some(BitVector::<12>::new(0b001111001111))}
        "pmpaddr32" => {Some(BitVector::<12>::new(0b001111010000))}
        "pmpaddr33" => {Some(BitVector::<12>::new(0b001111010001))}
        "pmpaddr34" => {Some(BitVector::<12>::new(0b001111010010))}
        "pmpaddr35" => {Some(BitVector::<12>::new(0b001111010011))}
        "pmpaddr36" => {Some(BitVector::<12>::new(0b001111010100))}
        "pmpaddr37" => {Some(BitVector::<12>::new(0b001111010101))}
        "pmpaddr38" => {Some(BitVector::<12>::new(0b001111010110))}
        "pmpaddr39" => {Some(BitVector::<12>::new(0b001111010111))}
        "pmpaddr40" => {Some(BitVector::<12>::new(0b001111011000))}
        "pmpaddr41" => {Some(BitVector::<12>::new(0b001111011001))}
        "pmpaddr42" => {Some(BitVector::<12>::new(0b001111011010))}
        "pmpaddr43" => {Some(BitVector::<12>::new(0b001111011011))}
        "pmpaddr44" => {Some(BitVector::<12>::new(0b001111011100))}
        "pmpaddr45" => {Some(BitVector::<12>::new(0b001111011101))}
        "pmpaddr46" => {Some(BitVector::<12>::new(0b001111011110))}
        "pmpaddr47" => {Some(BitVector::<12>::new(0b001111011111))}
        "pmpaddr48" => {Some(BitVector::<12>::new(0b001111100000))}
        "pmpaddr49" => {Some(BitVector::<12>::new(0b001111100001))}
        "pmpaddr50" => {Some(BitVector::<12>::new(0b001111100010))}
        "pmpaddr51" => {Some(BitVector::<12>::new(0b001111100011))}
        "pmpaddr52" => {Some(BitVector::<12>::new(0b001111100100))}
        "pmpaddr53" => {Some(BitVector::<12>::new(0b001111100101))}
        "pmpaddr54" => {Some(BitVector::<12>::new(0b001111100110))}
        "pmpaddr55" => {Some(BitVector::<12>::new(0b001111100111))}
        "pmpaddr56" => {Some(BitVector::<12>::new(0b001111101000))}
        "pmpaddr57" => {Some(BitVector::<12>::new(0b001111101001))}
        "pmpaddr58" => {Some(BitVector::<12>::new(0b001111101010))}
        "pmpaddr59" => {Some(BitVector::<12>::new(0b001111101011))}
        "pmpaddr60" => {Some(BitVector::<12>::new(0b001111101100))}
        "pmpaddr61" => {Some(BitVector::<12>::new(0b001111101101))}
        "pmpaddr62" => {Some(BitVector::<12>::new(0b001111101110))}
        "pmpaddr63" => {Some(BitVector::<12>::new(0b001111101111))}
        "vstart" => {Some(BitVector::<12>::new(0b000000001000))}
        "vxsat" => {Some(BitVector::<12>::new(0b000000001001))}
        "vxrm" => {Some(BitVector::<12>::new(0b000000001010))}
        "vcsr" => {Some(BitVector::<12>::new(0b000000001111))}
        "vl" => {Some(BitVector::<12>::new(0b110000100000))}
        "vtype" => {Some(BitVector::<12>::new(0b110000100001))}
        "vlenb" => {Some(BitVector::<12>::new(0b110000100010))}
        "stvec" => {Some(BitVector::<12>::new(0b000100000101))}
        "sepc" => {Some(BitVector::<12>::new(0b000101000001))}
        "mtvec" => {Some(BitVector::<12>::new(0b001100000101))}
        "mepc" => {Some(BitVector::<12>::new(0b001101000001))}
        "hpmcounter3" => {Some(BitVector::<12>::new(0b110000000011))}
        "hpmcounter4" => {Some(BitVector::<12>::new(0b110000000100))}
        "hpmcounter5" => {Some(BitVector::<12>::new(0b110000000101))}
        "hpmcounter6" => {Some(BitVector::<12>::new(0b110000000110))}
        "hpmcounter7" => {Some(BitVector::<12>::new(0b110000000111))}
        "hpmcounter8" => {Some(BitVector::<12>::new(0b110000001000))}
        "hpmcounter9" => {Some(BitVector::<12>::new(0b110000001001))}
        "hpmcounter10" => {Some(BitVector::<12>::new(0b110000001010))}
        "hpmcounter11" => {Some(BitVector::<12>::new(0b110000001011))}
        "hpmcounter12" => {Some(BitVector::<12>::new(0b110000001100))}
        "hpmcounter13" => {Some(BitVector::<12>::new(0b110000001101))}
        "hpmcounter14" => {Some(BitVector::<12>::new(0b110000001110))}
        "hpmcounter15" => {Some(BitVector::<12>::new(0b110000001111))}
        "hpmcounter16" => {Some(BitVector::<12>::new(0b110000010000))}
        "hpmcounter17" => {Some(BitVector::<12>::new(0b110000010001))}
        "hpmcounter18" => {Some(BitVector::<12>::new(0b110000010010))}
        "hpmcounter19" => {Some(BitVector::<12>::new(0b110000010011))}
        "hpmcounter20" => {Some(BitVector::<12>::new(0b110000010100))}
        "hpmcounter21" => {Some(BitVector::<12>::new(0b110000010101))}
        "hpmcounter22" => {Some(BitVector::<12>::new(0b110000010110))}
        "hpmcounter23" => {Some(BitVector::<12>::new(0b110000010111))}
        "hpmcounter24" => {Some(BitVector::<12>::new(0b110000011000))}
        "hpmcounter25" => {Some(BitVector::<12>::new(0b110000011001))}
        "hpmcounter26" => {Some(BitVector::<12>::new(0b110000011010))}
        "hpmcounter27" => {Some(BitVector::<12>::new(0b110000011011))}
        "hpmcounter28" => {Some(BitVector::<12>::new(0b110000011100))}
        "hpmcounter29" => {Some(BitVector::<12>::new(0b110000011101))}
        "hpmcounter30" => {Some(BitVector::<12>::new(0b110000011110))}
        "hpmcounter31" => {Some(BitVector::<12>::new(0b110000011111))}
        "hpmcounter3h" => {Some(BitVector::<12>::new(0b110010000011))}
        "hpmcounter4h" => {Some(BitVector::<12>::new(0b110010000100))}
        "hpmcounter5h" => {Some(BitVector::<12>::new(0b110010000101))}
        "hpmcounter6h" => {Some(BitVector::<12>::new(0b110010000110))}
        "hpmcounter7h" => {Some(BitVector::<12>::new(0b110010000111))}
        "hpmcounter8h" => {Some(BitVector::<12>::new(0b110010001000))}
        "hpmcounter9h" => {Some(BitVector::<12>::new(0b110010001001))}
        "hpmcounter10h" => {Some(BitVector::<12>::new(0b110010001010))}
        "hpmcounter11h" => {Some(BitVector::<12>::new(0b110010001011))}
        "hpmcounter12h" => {Some(BitVector::<12>::new(0b110010001100))}
        "hpmcounter13h" => {Some(BitVector::<12>::new(0b110010001101))}
        "hpmcounter14h" => {Some(BitVector::<12>::new(0b110010001110))}
        "hpmcounter15h" => {Some(BitVector::<12>::new(0b110010001111))}
        "hpmcounter16h" => {Some(BitVector::<12>::new(0b110010010000))}
        "hpmcounter17h" => {Some(BitVector::<12>::new(0b110010010001))}
        "hpmcounter18h" => {Some(BitVector::<12>::new(0b110010010010))}
        "hpmcounter19h" => {Some(BitVector::<12>::new(0b110010010011))}
        "hpmcounter20h" => {Some(BitVector::<12>::new(0b110010010100))}
        "hpmcounter21h" => {Some(BitVector::<12>::new(0b110010010101))}
        "hpmcounter22h" => {Some(BitVector::<12>::new(0b110010010110))}
        "hpmcounter23h" => {Some(BitVector::<12>::new(0b110010010111))}
        "hpmcounter24h" => {Some(BitVector::<12>::new(0b110010011000))}
        "hpmcounter25h" => {Some(BitVector::<12>::new(0b110010011001))}
        "hpmcounter26h" => {Some(BitVector::<12>::new(0b110010011010))}
        "hpmcounter27h" => {Some(BitVector::<12>::new(0b110010011011))}
        "hpmcounter28h" => {Some(BitVector::<12>::new(0b110010011100))}
        "hpmcounter29h" => {Some(BitVector::<12>::new(0b110010011101))}
        "hpmcounter30h" => {Some(BitVector::<12>::new(0b110010011110))}
        "hpmcounter31h" => {Some(BitVector::<12>::new(0b110010011111))}
        "mhpmevent3" => {Some(BitVector::<12>::new(0b001100100011))}
        "mhpmevent4" => {Some(BitVector::<12>::new(0b001100100100))}
        "mhpmevent5" => {Some(BitVector::<12>::new(0b001100100101))}
        "mhpmevent6" => {Some(BitVector::<12>::new(0b001100100110))}
        "mhpmevent7" => {Some(BitVector::<12>::new(0b001100100111))}
        "mhpmevent8" => {Some(BitVector::<12>::new(0b001100101000))}
        "mhpmevent9" => {Some(BitVector::<12>::new(0b001100101001))}
        "mhpmevent10" => {Some(BitVector::<12>::new(0b001100101010))}
        "mhpmevent11" => {Some(BitVector::<12>::new(0b001100101011))}
        "mhpmevent12" => {Some(BitVector::<12>::new(0b001100101100))}
        "mhpmevent13" => {Some(BitVector::<12>::new(0b001100101101))}
        "mhpmevent14" => {Some(BitVector::<12>::new(0b001100101110))}
        "mhpmevent15" => {Some(BitVector::<12>::new(0b001100101111))}
        "mhpmevent16" => {Some(BitVector::<12>::new(0b001100110000))}
        "mhpmevent17" => {Some(BitVector::<12>::new(0b001100110001))}
        "mhpmevent18" => {Some(BitVector::<12>::new(0b001100110010))}
        "mhpmevent19" => {Some(BitVector::<12>::new(0b001100110011))}
        "mhpmevent20" => {Some(BitVector::<12>::new(0b001100110100))}
        "mhpmevent21" => {Some(BitVector::<12>::new(0b001100110101))}
        "mhpmevent22" => {Some(BitVector::<12>::new(0b001100110110))}
        "mhpmevent23" => {Some(BitVector::<12>::new(0b001100110111))}
        "mhpmevent24" => {Some(BitVector::<12>::new(0b001100111000))}
        "mhpmevent25" => {Some(BitVector::<12>::new(0b001100111001))}
        "mhpmevent26" => {Some(BitVector::<12>::new(0b001100111010))}
        "mhpmevent27" => {Some(BitVector::<12>::new(0b001100111011))}
        "mhpmevent28" => {Some(BitVector::<12>::new(0b001100111100))}
        "mhpmevent29" => {Some(BitVector::<12>::new(0b001100111101))}
        "mhpmevent30" => {Some(BitVector::<12>::new(0b001100111110))}
        "mhpmevent31" => {Some(BitVector::<12>::new(0b001100111111))}
        "mhpmcounter3" => {Some(BitVector::<12>::new(0b101100000011))}
        "mhpmcounter4" => {Some(BitVector::<12>::new(0b101100000100))}
        "mhpmcounter5" => {Some(BitVector::<12>::new(0b101100000101))}
        "mhpmcounter6" => {Some(BitVector::<12>::new(0b101100000110))}
        "mhpmcounter7" => {Some(BitVector::<12>::new(0b101100000111))}
        "mhpmcounter8" => {Some(BitVector::<12>::new(0b101100001000))}
        "mhpmcounter9" => {Some(BitVector::<12>::new(0b101100001001))}
        "mhpmcounter10" => {Some(BitVector::<12>::new(0b101100001010))}
        "mhpmcounter11" => {Some(BitVector::<12>::new(0b101100001011))}
        "mhpmcounter12" => {Some(BitVector::<12>::new(0b101100001100))}
        "mhpmcounter13" => {Some(BitVector::<12>::new(0b101100001101))}
        "mhpmcounter14" => {Some(BitVector::<12>::new(0b101100001110))}
        "mhpmcounter15" => {Some(BitVector::<12>::new(0b101100001111))}
        "mhpmcounter16" => {Some(BitVector::<12>::new(0b101100010000))}
        "mhpmcounter17" => {Some(BitVector::<12>::new(0b101100010001))}
        "mhpmcounter18" => {Some(BitVector::<12>::new(0b101100010010))}
        "mhpmcounter19" => {Some(BitVector::<12>::new(0b101100010011))}
        "mhpmcounter20" => {Some(BitVector::<12>::new(0b101100010100))}
        "mhpmcounter21" => {Some(BitVector::<12>::new(0b101100010101))}
        "mhpmcounter22" => {Some(BitVector::<12>::new(0b101100010110))}
        "mhpmcounter23" => {Some(BitVector::<12>::new(0b101100010111))}
        "mhpmcounter24" => {Some(BitVector::<12>::new(0b101100011000))}
        "mhpmcounter25" => {Some(BitVector::<12>::new(0b101100011001))}
        "mhpmcounter26" => {Some(BitVector::<12>::new(0b101100011010))}
        "mhpmcounter27" => {Some(BitVector::<12>::new(0b101100011011))}
        "mhpmcounter28" => {Some(BitVector::<12>::new(0b101100011100))}
        "mhpmcounter29" => {Some(BitVector::<12>::new(0b101100011101))}
        "mhpmcounter30" => {Some(BitVector::<12>::new(0b101100011110))}
        "mhpmcounter31" => {Some(BitVector::<12>::new(0b101100011111))}
        "mhpmcounter3h" => {Some(BitVector::<12>::new(0b101110000011))}
        "mhpmcounter4h" => {Some(BitVector::<12>::new(0b101110000100))}
        "mhpmcounter5h" => {Some(BitVector::<12>::new(0b101110000101))}
        "mhpmcounter6h" => {Some(BitVector::<12>::new(0b101110000110))}
        "mhpmcounter7h" => {Some(BitVector::<12>::new(0b101110000111))}
        "mhpmcounter8h" => {Some(BitVector::<12>::new(0b101110001000))}
        "mhpmcounter9h" => {Some(BitVector::<12>::new(0b101110001001))}
        "mhpmcounter10h" => {Some(BitVector::<12>::new(0b101110001010))}
        "mhpmcounter11h" => {Some(BitVector::<12>::new(0b101110001011))}
        "mhpmcounter12h" => {Some(BitVector::<12>::new(0b101110001100))}
        "mhpmcounter13h" => {Some(BitVector::<12>::new(0b101110001101))}
        "mhpmcounter14h" => {Some(BitVector::<12>::new(0b101110001110))}
        "mhpmcounter15h" => {Some(BitVector::<12>::new(0b101110001111))}
        "mhpmcounter16h" => {Some(BitVector::<12>::new(0b101110010000))}
        "mhpmcounter17h" => {Some(BitVector::<12>::new(0b101110010001))}
        "mhpmcounter18h" => {Some(BitVector::<12>::new(0b101110010010))}
        "mhpmcounter19h" => {Some(BitVector::<12>::new(0b101110010011))}
        "mhpmcounter20h" => {Some(BitVector::<12>::new(0b101110010100))}
        "mhpmcounter21h" => {Some(BitVector::<12>::new(0b101110010101))}
        "mhpmcounter22h" => {Some(BitVector::<12>::new(0b101110010110))}
        "mhpmcounter23h" => {Some(BitVector::<12>::new(0b101110010111))}
        "mhpmcounter24h" => {Some(BitVector::<12>::new(0b101110011000))}
        "mhpmcounter25h" => {Some(BitVector::<12>::new(0b101110011001))}
        "mhpmcounter26h" => {Some(BitVector::<12>::new(0b101110011010))}
        "mhpmcounter27h" => {Some(BitVector::<12>::new(0b101110011011))}
        "mhpmcounter28h" => {Some(BitVector::<12>::new(0b101110011100))}
        "mhpmcounter29h" => {Some(BitVector::<12>::new(0b101110011101))}
        "mhpmcounter30h" => {Some(BitVector::<12>::new(0b101110011110))}
        "mhpmcounter31h" => {Some(BitVector::<12>::new(0b101110011111))}
        "mhpmcounter3h" => {Some(BitVector::<12>::new(0b101110000011))}
        "mhpmcounter4h" => {Some(BitVector::<12>::new(0b101110000100))}
        "mhpmcounter5h" => {Some(BitVector::<12>::new(0b101110000101))}
        "mhpmcounter6h" => {Some(BitVector::<12>::new(0b101110000110))}
        "mhpmcounter7h" => {Some(BitVector::<12>::new(0b101110000111))}
        "mhpmcounter8h" => {Some(BitVector::<12>::new(0b101110001000))}
        "mhpmcounter9h" => {Some(BitVector::<12>::new(0b101110001001))}
        "mhpmcounter10h" => {Some(BitVector::<12>::new(0b101110001010))}
        "mhpmcounter11h" => {Some(BitVector::<12>::new(0b101110001011))}
        "mhpmcounter12h" => {Some(BitVector::<12>::new(0b101110001100))}
        "mhpmcounter13h" => {Some(BitVector::<12>::new(0b101110001101))}
        "mhpmcounter14h" => {Some(BitVector::<12>::new(0b101110001110))}
        "mhpmcounter15h" => {Some(BitVector::<12>::new(0b101110001111))}
        "mhpmcounter16h" => {Some(BitVector::<12>::new(0b101110010000))}
        "mhpmcounter17h" => {Some(BitVector::<12>::new(0b101110010001))}
        "mhpmcounter18h" => {Some(BitVector::<12>::new(0b101110010010))}
        "mhpmcounter19h" => {Some(BitVector::<12>::new(0b101110010011))}
        "mhpmcounter20h" => {Some(BitVector::<12>::new(0b101110010100))}
        "mhpmcounter21h" => {Some(BitVector::<12>::new(0b101110010101))}
        "mhpmcounter22h" => {Some(BitVector::<12>::new(0b101110010110))}
        "mhpmcounter23h" => {Some(BitVector::<12>::new(0b101110010111))}
        "mhpmcounter24h" => {Some(BitVector::<12>::new(0b101110011000))}
        "mhpmcounter25h" => {Some(BitVector::<12>::new(0b101110011001))}
        "mhpmcounter26h" => {Some(BitVector::<12>::new(0b101110011010))}
        "mhpmcounter27h" => {Some(BitVector::<12>::new(0b101110011011))}
        "mhpmcounter28h" => {Some(BitVector::<12>::new(0b101110011100))}
        "mhpmcounter29h" => {Some(BitVector::<12>::new(0b101110011101))}
        "mhpmcounter30h" => {Some(BitVector::<12>::new(0b101110011110))}
        "mhpmcounter31h" => {Some(BitVector::<12>::new(0b101110011111))}
        "scountovf" => {Some(BitVector::<12>::new(0b110110100000))}
        "seed" => {Some(BitVector::<12>::new(0b000000010101))}
        "cycle" => {Some(BitVector::<12>::new(0b110000000000))}
        "time" => {Some(BitVector::<12>::new(0b110000000001))}
        "instret" => {Some(BitVector::<12>::new(0b110000000010))}
        "cycleh" => {Some(BitVector::<12>::new(0b110010000000))}
        "timeh" => {Some(BitVector::<12>::new(0b110010000001))}
        "instreth" => {Some(BitVector::<12>::new(0b110010000010))}
        "mcycle" => {Some(BitVector::<12>::new(0b101100000000))}
        "minstret" => {Some(BitVector::<12>::new(0b101100000010))}
        "mcycleh" => {Some(BitVector::<12>::new(0b101110000000))}
        "minstreth" => {Some(BitVector::<12>::new(0b101110000010))}
        "fflags" => {Some(BitVector::<12>::new(0b000000000001))}
        "frm" => {Some(BitVector::<12>::new(0b000000000010))}
        "fcsr" => {Some(BitVector::<12>::new(0b000000000011))}
        "mcyclecfg" => {Some(BitVector::<12>::new(0b001100100001))}
        "mcyclecfgh" => {Some(BitVector::<12>::new(0b011100100001))}
        "minstretcfg" => {Some(BitVector::<12>::new(0b001100100010))}
        "minstretcfgh" => {Some(BitVector::<12>::new(0b011100100010))}
        "stimecmp" => {Some(BitVector::<12>::new(0b000101001101))}
        "stimecmph" => {Some(BitVector::<12>::new(0b000101011101))}
        "satp" => {Some(BitVector::<12>::new(0b000110000000))}
        mapping0_hashtag_ if {hex_bits_12_backwards_matches(mapping0_hashtag_)} => {match hex_bits_12_backwards(mapping0_hashtag_) {
            reg => {Some(reg)}
            _ => {None}
            _ => {panic!("Unreachable code")}
        }}
        _ => {None}
        _ => {panic!("Unreachable code")}
    } {
        Some(result) => {result}
        _ => {panic!("Unreachable code")}
    }
}

/// csr_id_read_callback
/// 
/// Generated from the Sail sources at `riscv_callbacks.sail` L47-50.
pub fn csr_id_read_callback(csr: BitVector<12>, value: BitVector<{
    64
}>) {
    let name = csr_name_map_forwards(csr);
    
}

pub type regtype = xlenbits;

pub const zero_reg: regtype = zeros::<64>(64);

/// regval_from_reg
/// 
/// Generated from the Sail sources at `riscv_reg_type.sail` L22.
pub fn regval_from_reg(r: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    r
}

/// regval_into_reg
/// 
/// Generated from the Sail sources at `riscv_reg_type.sail` L25.
pub fn regval_into_reg(v: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    v
}

pub type fregtype = flenbits;

pub const zero_freg: fregtype = zeros::<64>(64);

/// rX
/// 
/// Generated from the Sail sources at `riscv_regs.sail` L48-86.
pub fn rX(core_ctx: &mut Core, regno::Regno(r): regno) -> BitVector<{
    64
}> {
    let v: regtype = match r {
        l__583 if {(l__583 == 0)} => {zero_reg}
        l__584 if {(l__584 == 1)} => {core_ctx.x1}
        l__585 if {(l__585 == 2)} => {core_ctx.x2}
        l__586 if {(l__586 == 3)} => {core_ctx.x3}
        l__587 if {(l__587 == 4)} => {core_ctx.x4}
        l__588 if {(l__588 == 5)} => {core_ctx.x5}
        l__589 if {(l__589 == 6)} => {core_ctx.x6}
        l__590 if {(l__590 == 7)} => {core_ctx.x7}
        l__591 if {(l__591 == 8)} => {core_ctx.x8}
        l__592 if {(l__592 == 9)} => {core_ctx.x9}
        l__593 if {(l__593 == 10)} => {core_ctx.x10}
        l__594 if {(l__594 == 11)} => {core_ctx.x11}
        l__595 if {(l__595 == 12)} => {core_ctx.x12}
        l__596 if {(l__596 == 13)} => {core_ctx.x13}
        l__597 if {(l__597 == 14)} => {core_ctx.x14}
        l__598 if {(l__598 == 15)} => {core_ctx.x15}
        l__599 if {(l__599 == 16)} => {core_ctx.x16}
        l__600 if {(l__600 == 17)} => {core_ctx.x17}
        l__601 if {(l__601 == 18)} => {core_ctx.x18}
        l__602 if {(l__602 == 19)} => {core_ctx.x19}
        l__603 if {(l__603 == 20)} => {core_ctx.x20}
        l__604 if {(l__604 == 21)} => {core_ctx.x21}
        l__605 if {(l__605 == 22)} => {core_ctx.x22}
        l__606 if {(l__606 == 23)} => {core_ctx.x23}
        l__607 if {(l__607 == 24)} => {core_ctx.x24}
        l__608 if {(l__608 == 25)} => {core_ctx.x25}
        l__609 if {(l__609 == 26)} => {core_ctx.x26}
        l__610 if {(l__610 == 27)} => {core_ctx.x27}
        l__611 if {(l__611 == 28)} => {core_ctx.x28}
        l__612 if {(l__612 == 29)} => {core_ctx.x29}
        l__613 if {(l__613 == 30)} => {core_ctx.x30}
        l__614 if {(l__614 == 31)} => {core_ctx.x31}
        _ => {{
            assert!(false, "invalid register number");
            panic!("exit")
        }}
        _ => {panic!("Unreachable code")}
    };
    regval_from_reg(v)
}

/// wX
/// 
/// Generated from the Sail sources at `riscv_regs.sail` L88-126.
pub fn wX(core_ctx: &mut Core, regno::Regno(r): regno, in_v: BitVector<{
    64
}>) {
    let v = regval_into_reg(in_v);
    match r {
        l__551 if {(l__551 == 0)} => {()}
        l__552 if {(l__552 == 1)} => {core_ctx.x1 = v}
        l__553 if {(l__553 == 2)} => {core_ctx.x2 = v}
        l__554 if {(l__554 == 3)} => {core_ctx.x3 = v}
        l__555 if {(l__555 == 4)} => {core_ctx.x4 = v}
        l__556 if {(l__556 == 5)} => {core_ctx.x5 = v}
        l__557 if {(l__557 == 6)} => {core_ctx.x6 = v}
        l__558 if {(l__558 == 7)} => {core_ctx.x7 = v}
        l__559 if {(l__559 == 8)} => {core_ctx.x8 = v}
        l__560 if {(l__560 == 9)} => {core_ctx.x9 = v}
        l__561 if {(l__561 == 10)} => {core_ctx.x10 = v}
        l__562 if {(l__562 == 11)} => {core_ctx.x11 = v}
        l__563 if {(l__563 == 12)} => {core_ctx.x12 = v}
        l__564 if {(l__564 == 13)} => {core_ctx.x13 = v}
        l__565 if {(l__565 == 14)} => {core_ctx.x14 = v}
        l__566 if {(l__566 == 15)} => {core_ctx.x15 = v}
        l__567 if {(l__567 == 16)} => {core_ctx.x16 = v}
        l__568 if {(l__568 == 17)} => {core_ctx.x17 = v}
        l__569 if {(l__569 == 18)} => {core_ctx.x18 = v}
        l__570 if {(l__570 == 19)} => {core_ctx.x19 = v}
        l__571 if {(l__571 == 20)} => {core_ctx.x20 = v}
        l__572 if {(l__572 == 21)} => {core_ctx.x21 = v}
        l__573 if {(l__573 == 22)} => {core_ctx.x22 = v}
        l__574 if {(l__574 == 23)} => {core_ctx.x23 = v}
        l__575 if {(l__575 == 24)} => {core_ctx.x24 = v}
        l__576 if {(l__576 == 25)} => {core_ctx.x25 = v}
        l__577 if {(l__577 == 26)} => {core_ctx.x26 = v}
        l__578 if {(l__578 == 27)} => {core_ctx.x27 = v}
        l__579 if {(l__579 == 28)} => {core_ctx.x28 = v}
        l__580 if {(l__580 == 29)} => {core_ctx.x29 = v}
        l__581 if {(l__581 == 30)} => {core_ctx.x30 = v}
        l__582 if {(l__582 == 31)} => {core_ctx.x31 = v}
        _ => {assert!(false, "invalid register number")}
        _ => {panic!("Unreachable code")}
    };
    if {(r != 0)} {
        ()
    } else {
        ()
    }
}

/// rX_bits
/// 
/// Generated from the Sail sources at `riscv_regs.sail` L128.
pub fn rX_bits(core_ctx: &mut Core, i: regidx) -> BitVector<{
    64
}> {
    rX(core_ctx, regidx_to_regno(i))
}

/// wX_bits
/// 
/// Generated from the Sail sources at `riscv_regs.sail` L130-132.
pub fn wX_bits(core_ctx: &mut Core, i: regidx, data: BitVector<{
    64
}>) {
    wX(core_ctx, regidx_to_regno(i), data)
}

/// encdec_reg_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_reg_forwards(arg_hashtag_: regidx) -> BitVector<5> {
    match arg_hashtag_ {
        regidx::Regidx(r) => {r}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_reg_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_reg_backwards(arg_hashtag_: BitVector<5>) -> regidx {
    match arg_hashtag_ {
        r => {regidx::Regidx(r)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_reg_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_reg_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        r => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// get_arch_pc
/// 
/// Generated from the Sail sources at `riscv_pc_access.sail` L18.
pub fn get_arch_pc(core_ctx: &mut Core, unit_arg: ()) -> BitVector<{
    64
}> {
    core_ctx.PC
}

/// get_next_pc
/// 
/// Generated from the Sail sources at `riscv_pc_access.sail` L21.
pub fn get_next_pc(core_ctx: &mut Core, unit_arg: ()) -> BitVector<{
    64
}> {
    core_ctx.nextPC
}

/// set_next_pc
/// 
/// Generated from the Sail sources at `riscv_pc_access.sail` L24-27.
pub fn set_next_pc(core_ctx: &mut Core, pc: BitVector<{
    64
}>) {
    core_ctx.nextPC = pc
}

/// Misa
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L49-78.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Misa {
    pub bits: BitVector<{
    64
}>,
}

/// Mk_Misa
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Misa(v: BitVector<64>) -> Misa {
    Misa {
        bits: v
    }
}

/// CountSmcntrpmf
/// 
/// Generated from the Sail sources at `riscv_smcntrpmf.sail` L3-9.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct CountSmcntrpmf {
    pub bits: BitVector<64>,
}

/// Counteren
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L581-586.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Counteren {
    pub bits: BitVector<32>,
}

/// Counterin
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L614-618.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Counterin {
    pub bits: BitVector<32>,
}

/// Fcsr
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L384-387.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Fcsr {
    pub bits: BitVector<32>,
}

/// HpmEvent
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L165-175.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct HpmEvent {
    pub bits: BitVector<64>,
}

/// MEnvcfg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L315-332.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct MEnvcfg {
    pub bits: BitVector<64>,
}

/// Mcause
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L518-521.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Mcause {
    pub bits: BitVector<{
    64
}>,
}

/// Medeleg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L449-464.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Medeleg {
    pub bits: BitVector<64>,
}

/// Minterrupts
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L404-413.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Minterrupts {
    pub bits: BitVector<{
    64
}>,
}

/// Mstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L168-204.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Mstatus {
    pub bits: BitVector<64>,
}

/// Mtvec
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L503-506.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Mtvec {
    pub bits: BitVector<{
    64
}>,
}

/// PTE_Ext
/// 
/// Generated from the Sail sources at `riscv_vmem_pte.sail` L25-31.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct PTE_Ext {
    pub bits: BitVector<10>,
}

/// PTE_Flags
/// 
/// Generated from the Sail sources at `riscv_vmem_pte.sail` L55-64.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct PTE_Flags {
    pub bits: BitVector<8>,
}

/// Pmpcfg_ent
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L33-41.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Pmpcfg_ent {
    pub bits: BitVector<8>,
}

/// SEnvcfg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L334-345.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct SEnvcfg {
    pub bits: BitVector<{
    64
}>,
}

/// Satp32
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L850-854.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Satp32 {
    pub bits: BitVector<32>,
}

/// Satp64
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L844-848.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Satp64 {
    pub bits: BitVector<64>,
}

/// Sinterrupts
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L746-752.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Sinterrupts {
    pub bits: BitVector<{
    64
}>,
}

/// Sstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L680-694.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Sstatus {
    pub bits: BitVector<64>,
}

/// Vcsr
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L226-229.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Vcsr {
    pub bits: BitVector<3>,
}

/// Vtype
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L923-930.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct Vtype {
    pub bits: BitVector<{
    64
}>,
}

/// htif_cmd
/// 
/// Generated from the Sail sources at `riscv_platform.sail` L283-287.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct htif_cmd {
    pub bits: BitVector<64>,
}

/// _get_Misa_A
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_A(v: Misa) -> BitVector<1> {
    v.bits.subrange::<0, 1, 1>()
}

/// _update_Misa_A
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_A(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 0, 0, x)
    }
}

/// _update_Pmpcfg_ent_A
/// 
/// Generated from the Sail sources.
pub fn _update_Pmpcfg_ent_A(v: Pmpcfg_ent, x: BitVector<2>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: update_subrange_bits(v.bits, 4, 3, x)
    }
}

/// _get_Pmpcfg_ent_A
/// 
/// Generated from the Sail sources.
pub fn _get_Pmpcfg_ent_A(v: Pmpcfg_ent) -> BitVector<2> {
    v.bits.subrange::<3, 5, 2>()
}

/// _get_Misa_B
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_B(v: Misa) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _update_Misa_B
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_B(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _get_Misa_C
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_C(v: Misa) -> BitVector<1> {
    v.bits.subrange::<2, 3, 1>()
}

/// _update_Misa_C
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_C(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 2, 2, x)
    }
}

/// _get_Misa_D
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_D(v: Misa) -> BitVector<1> {
    v.bits.subrange::<3, 4, 1>()
}

/// _update_Misa_D
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_D(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 3, 3, x)
    }
}

/// _get_Misa_F
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_F(v: Misa) -> BitVector<1> {
    v.bits.subrange::<5, 6, 1>()
}

/// _update_Misa_F
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_F(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 5, 5, x)
    }
}

/// _update_Misa_I
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_I(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 8, 8, x)
    }
}

/// _update_Pmpcfg_ent_L
/// 
/// Generated from the Sail sources.
pub fn _update_Pmpcfg_ent_L(v: Pmpcfg_ent, x: BitVector<1>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: update_subrange_bits(v.bits, 7, 7, x)
    }
}

/// _get_Pmpcfg_ent_L
/// 
/// Generated from the Sail sources.
pub fn _get_Pmpcfg_ent_L(v: Pmpcfg_ent) -> BitVector<1> {
    v.bits.subrange::<7, 8, 1>()
}

/// _get_Misa_M
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_M(v: Misa) -> BitVector<1> {
    v.bits.subrange::<12, 13, 1>()
}

/// _update_Misa_M
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_M(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 12, 12, x)
    }
}

/// _get_Misa_MXL
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_MXL(v: Misa) -> BitVector<2> {
    v.bits.subrange::<62, 64, 2>()
}

/// _update_Misa_MXL
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_MXL(v: Misa, x: BitVector<2>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 63, 62, x)
    }
}

/// _update_Pmpcfg_ent_R
/// 
/// Generated from the Sail sources.
pub fn _update_Pmpcfg_ent_R(v: Pmpcfg_ent, x: BitVector<1>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: update_subrange_bits(v.bits, 0, 0, x)
    }
}

/// _get_Pmpcfg_ent_R
/// 
/// Generated from the Sail sources.
pub fn _get_Pmpcfg_ent_R(v: Pmpcfg_ent) -> BitVector<1> {
    v.bits.subrange::<0, 1, 1>()
}

/// _get_Misa_S
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_S(v: Misa) -> BitVector<1> {
    v.bits.subrange::<18, 19, 1>()
}

/// _update_Misa_S
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_S(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 18, 18, x)
    }
}

/// _get_Misa_U
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_U(v: Misa) -> BitVector<1> {
    v.bits.subrange::<20, 21, 1>()
}

/// _update_Misa_U
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_U(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 20, 20, x)
    }
}

/// _get_Misa_V
/// 
/// Generated from the Sail sources.
pub fn _get_Misa_V(v: Misa) -> BitVector<1> {
    v.bits.subrange::<21, 22, 1>()
}

/// _update_Misa_V
/// 
/// Generated from the Sail sources.
pub fn _update_Misa_V(v: Misa, x: BitVector<1>) -> Misa {
    Misa {
        bits: update_subrange_bits(v.bits, 21, 21, x)
    }
}

/// _update_Pmpcfg_ent_W
/// 
/// Generated from the Sail sources.
pub fn _update_Pmpcfg_ent_W(v: Pmpcfg_ent, x: BitVector<1>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _get_Pmpcfg_ent_W
/// 
/// Generated from the Sail sources.
pub fn _get_Pmpcfg_ent_W(v: Pmpcfg_ent) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _update_Pmpcfg_ent_X
/// 
/// Generated from the Sail sources.
pub fn _update_Pmpcfg_ent_X(v: Pmpcfg_ent, x: BitVector<1>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: update_subrange_bits(v.bits, 2, 2, x)
    }
}

/// _get_Pmpcfg_ent_X
/// 
/// Generated from the Sail sources.
pub fn _get_Pmpcfg_ent_X(v: Pmpcfg_ent) -> BitVector<1> {
    v.bits.subrange::<2, 3, 1>()
}

/// sys_enable_writable_misa
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L86.
pub fn sys_enable_writable_misa(core_ctx: &mut Core, unit_arg: ()) -> bool {
    core_ctx.config.base.writable_misa
}

/// sys_enable_writable_fiom
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L90.
pub fn sys_enable_writable_fiom(core_ctx: &mut Core, unit_arg: ()) -> bool {
    core_ctx.config.base.writable_fiom
}

/// sys_pmp_count
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L93.
pub fn sys_pmp_count(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    core_ctx.config.memory.pmp.count
}

/// sys_pmp_grain
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L97.
pub fn sys_pmp_grain(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    core_ctx.config.memory.pmp.grain
}

/// sys_writable_hpm_counters
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L100.
pub fn sys_writable_hpm_counters(core_ctx: &mut Core, unit_arg: ()) -> BitVector<32> {
    core_ctx.config.base.writable_hpm_counters
}

/// ext_veto_disable_C
/// 
/// Generated from the Sail sources at `riscv_misa_ext.sail` L9.
pub const fn ext_veto_disable_C(unit_arg: ()) -> bool {
    false
}

/// legalize_misa
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L110-130.
pub fn legalize_misa(core_ctx: &mut Core, m: Misa, v: BitVector<{
    64
}>) -> Misa {
    let v = Mk_Misa(v);
    if {(!(sys_enable_writable_misa(core_ctx, ())) || ((_get_Misa_C(v) == BitVector::<1>::new(0b0)) && (bitvector_access(core_ctx.nextPC, 1) == true)))} {
        m
    } else {
        {
            let var_1 = {
                let var_3 = {
                    let var_5 = {
                        let var_7 = {
                            let var_9 = {
                                let var_10 = {
                                    let var_12 = {
                                        let var_14 = {
                                            let var_16 = {
                                                let var_18 = if {hartSupports(core_ctx, extension::Ext_A)} {
                                                    _get_Misa_A(v)
                                                } else {
                                                    BitVector::<1>::new(0b0)
                                                };
                                                _update_Misa_A(m, var_18)
                                            };
                                            let var_17 = if {hartSupports(core_ctx, extension::Ext_B)} {
                                                _get_Misa_B(v)
                                            } else {
                                                BitVector::<1>::new(0b0)
                                            };
                                            _update_Misa_B(var_16, var_17)
                                        };
                                        let var_15 = if {hartSupports(core_ctx, extension::Ext_C)} {
                                            _get_Misa_C(v)
                                        } else {
                                            BitVector::<1>::new(0b0)
                                        };
                                        _update_Misa_C(var_14, var_15)
                                    };
                                    let var_13 = if {(hartSupports(core_ctx, extension::Ext_D) && (_get_Misa_F(v) == BitVector::<1>::new(0b1)))} {
                                        _get_Misa_D(v)
                                    } else {
                                        BitVector::<1>::new(0b0)
                                    };
                                    _update_Misa_D(var_12, var_13)
                                };
                                let var_11 = if {hartSupports(core_ctx, extension::Ext_F)} {
                                    _get_Misa_F(v)
                                } else {
                                    BitVector::<1>::new(0b0)
                                };
                                _update_Misa_F(var_10, var_11)
                            };
                            _update_Misa_I(var_9, BitVector::<1>::new(0b1))
                        };
                        let var_8 = if {hartSupports(core_ctx, extension::Ext_M)} {
                            _get_Misa_M(v)
                        } else {
                            BitVector::<1>::new(0b0)
                        };
                        _update_Misa_M(var_7, var_8)
                    };
                    let var_6 = if {(hartSupports(core_ctx, extension::Ext_S) && (_get_Misa_U(v) == BitVector::<1>::new(0b1)))} {
                        _get_Misa_S(v)
                    } else {
                        BitVector::<1>::new(0b0)
                    };
                    _update_Misa_S(var_5, var_6)
                };
                let var_4 = if {hartSupports(core_ctx, extension::Ext_U)} {
                    _get_Misa_U(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_Misa_U(var_3, var_4)
            };
            let var_2 = if {(hartSupports(core_ctx, extension::Ext_V) && ((_get_Misa_F(v) == BitVector::<1>::new(0b1)) && (_get_Misa_D(v) == BitVector::<1>::new(0b1))))} {
                _get_Misa_V(v)
            } else {
                BitVector::<1>::new(0b0)
            };
            _update_Misa_V(var_1, var_2)
        }
    }
}

/// Mk_Mstatus
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Mstatus(v: BitVector<64>) -> Mstatus {
    Mstatus {
        bits: v
    }
}

/// _update_Mstatus_SXL
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SXL(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 35, 34, x)
    }
}

/// _update_Mstatus_UXL
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_UXL(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 33, 32, x)
    }
}

/// _get_Mstatus_FS
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_FS(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<13, 15, 2>()
}

/// _get_Mstatus_VS
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_VS(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<9, 11, 2>()
}

/// currentlyEnabled
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L103.
pub fn currentlyEnabled(core_ctx: &mut Core, merge_hashtag_var: extension) -> bool {
    match merge_hashtag_var {
        extension::Ext_Sstc => {hartSupports(core_ctx, extension::Ext_Sstc)}
        extension::Ext_U => {(hartSupports(core_ctx, extension::Ext_U) && ({
            let var_1 = core_ctx.misa;
            _get_Misa_U(var_1)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_S => {(hartSupports(core_ctx, extension::Ext_S) && ({
            let var_2 = core_ctx.misa;
            _get_Misa_S(var_2)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_Svbare => {currentlyEnabled(core_ctx, extension::Ext_S)}
        extension::Ext_Sv32 => {(hartSupports(core_ctx, extension::Ext_Sv32) && currentlyEnabled(core_ctx, extension::Ext_S))}
        extension::Ext_Sv39 => {(hartSupports(core_ctx, extension::Ext_Sv39) && currentlyEnabled(core_ctx, extension::Ext_S))}
        extension::Ext_Sv48 => {(hartSupports(core_ctx, extension::Ext_Sv48) && currentlyEnabled(core_ctx, extension::Ext_S))}
        extension::Ext_Sv57 => {(hartSupports(core_ctx, extension::Ext_Sv57) && currentlyEnabled(core_ctx, extension::Ext_S))}
        extension::Ext_V => {(hartSupports(core_ctx, extension::Ext_V) && (({
            let var_4 = core_ctx.misa;
            _get_Misa_V(var_4)
        } == BitVector::<1>::new(0b1)) && ({
            let var_3 = core_ctx.mstatus;
            _get_Mstatus_VS(var_3)
        } != BitVector::<2>::new(0b00))))}
        extension::Ext_Zihpm => {(hartSupports(core_ctx, extension::Ext_Zihpm) && currentlyEnabled(core_ctx, extension::Ext_Zicntr))}
        extension::Ext_Sscofpmf => {(hartSupports(core_ctx, extension::Ext_Sscofpmf) && currentlyEnabled(core_ctx, extension::Ext_Zihpm))}
        extension::Ext_Zkr => {hartSupports(core_ctx, extension::Ext_Zkr)}
        extension::Ext_Zicntr => {hartSupports(core_ctx, extension::Ext_Zicntr)}
        extension::Ext_F => {(hartSupports(core_ctx, extension::Ext_F) && (({
            let var_6 = core_ctx.misa;
            _get_Misa_F(var_6)
        } == BitVector::<1>::new(0b1)) && ({
            let var_5 = core_ctx.mstatus;
            _get_Mstatus_FS(var_5)
        } != BitVector::<2>::new(0b00))))}
        extension::Ext_D => {(hartSupports(core_ctx, extension::Ext_D) && (({
            let var_8 = core_ctx.misa;
            _get_Misa_D(var_8)
        } == BitVector::<1>::new(0b1)) && ({
            let var_7 = core_ctx.mstatus;
            _get_Mstatus_FS(var_7)
        } != BitVector::<2>::new(0b00))))}
        extension::Ext_Zfinx => {hartSupports(core_ctx, extension::Ext_Zfinx)}
        extension::Ext_Smcntrpmf => {(hartSupports(core_ctx, extension::Ext_Smcntrpmf) && currentlyEnabled(core_ctx, extension::Ext_Zicntr))}
        extension::Ext_Svnapot => {false}
        extension::Ext_Svpbmt => {false}
        extension::Ext_C => {(hartSupports(core_ctx, extension::Ext_C) && ({
            let var_9 = core_ctx.misa;
            _get_Misa_C(var_9)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_Zca => {(hartSupports(core_ctx, extension::Ext_Zca) && (currentlyEnabled(core_ctx, extension::Ext_C) || !(hartSupports(core_ctx, extension::Ext_C))))}
        extension::Ext_Zifencei => {hartSupports(core_ctx, extension::Ext_Zifencei)}
        extension::Ext_A => {(hartSupports(core_ctx, extension::Ext_A) && ({
            let var_10 = core_ctx.misa;
            _get_Misa_A(var_10)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_Zabha => {(hartSupports(core_ctx, extension::Ext_Zabha) && currentlyEnabled(core_ctx, extension::Ext_Zaamo))}
        extension::Ext_Zalrsc => {(hartSupports(core_ctx, extension::Ext_Zalrsc) || currentlyEnabled(core_ctx, extension::Ext_A))}
        extension::Ext_Zaamo => {(hartSupports(core_ctx, extension::Ext_Zaamo) || currentlyEnabled(core_ctx, extension::Ext_A))}
        extension::Ext_M => {(hartSupports(core_ctx, extension::Ext_M) && ({
            let var_11 = core_ctx.misa;
            _get_Misa_M(var_11)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_Zmmul => {(hartSupports(core_ctx, extension::Ext_Zmmul) || currentlyEnabled(core_ctx, extension::Ext_M))}
        extension::Ext_Zfh => {(hartSupports(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_F))}
        extension::Ext_Zfhmin => {((hartSupports(core_ctx, extension::Ext_Zfhmin) && currentlyEnabled(core_ctx, extension::Ext_F)) || currentlyEnabled(core_ctx, extension::Ext_Zfh))}
        extension::Ext_Zcf => {(hartSupports(core_ctx, extension::Ext_Zcf) && (currentlyEnabled(core_ctx, extension::Ext_F) && (currentlyEnabled(core_ctx, extension::Ext_Zca) && (currentlyEnabled(core_ctx, extension::Ext_C) || !(hartSupports(core_ctx, extension::Ext_C))))))}
        extension::Ext_Zdinx => {hartSupports(core_ctx, extension::Ext_Zdinx)}
        extension::Ext_Zcd => {(hartSupports(core_ctx, extension::Ext_Zcd) && (currentlyEnabled(core_ctx, extension::Ext_D) && (currentlyEnabled(core_ctx, extension::Ext_Zca) && (currentlyEnabled(core_ctx, extension::Ext_C) || !(hartSupports(core_ctx, extension::Ext_C))))))}
        extension::Ext_Svinval => {hartSupports(core_ctx, extension::Ext_Svinval)}
        extension::Ext_B => {(hartSupports(core_ctx, extension::Ext_B) && ({
            let var_12 = core_ctx.misa;
            _get_Misa_B(var_12)
        } == BitVector::<1>::new(0b1)))}
        extension::Ext_Zba => {(hartSupports(core_ctx, extension::Ext_Zba) || currentlyEnabled(core_ctx, extension::Ext_B))}
        extension::Ext_Zbb => {(hartSupports(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_B))}
        extension::Ext_Zbkb => {hartSupports(core_ctx, extension::Ext_Zbkb)}
        extension::Ext_Zbc => {hartSupports(core_ctx, extension::Ext_Zbc)}
        extension::Ext_Zbkc => {hartSupports(core_ctx, extension::Ext_Zbkc)}
        extension::Ext_Zbs => {(hartSupports(core_ctx, extension::Ext_Zbs) || currentlyEnabled(core_ctx, extension::Ext_B))}
        extension::Ext_Zcb => {(hartSupports(core_ctx, extension::Ext_Zcb) && currentlyEnabled(core_ctx, extension::Ext_Zca))}
        extension::Ext_Zhinx => {(hartSupports(core_ctx, extension::Ext_Zhinx) && currentlyEnabled(core_ctx, extension::Ext_Zfinx))}
        extension::Ext_Zfa => {(hartSupports(core_ctx, extension::Ext_Zfa) && currentlyEnabled(core_ctx, extension::Ext_F))}
        extension::Ext_Zknh => {hartSupports(core_ctx, extension::Ext_Zknh)}
        extension::Ext_Zkne => {hartSupports(core_ctx, extension::Ext_Zkne)}
        extension::Ext_Zknd => {hartSupports(core_ctx, extension::Ext_Zknd)}
        extension::Ext_Zksh => {hartSupports(core_ctx, extension::Ext_Zksh)}
        extension::Ext_Zksed => {hartSupports(core_ctx, extension::Ext_Zksed)}
        extension::Ext_Zbkx => {hartSupports(core_ctx, extension::Ext_Zbkx)}
        extension::Ext_Zicond => {hartSupports(core_ctx, extension::Ext_Zicond)}
        extension::Ext_Zicbom => {hartSupports(core_ctx, extension::Ext_Zicbom)}
        extension::Ext_Zicboz => {hartSupports(core_ctx, extension::Ext_Zicboz)}
        extension::Ext_Zvbb => {(hartSupports(core_ctx, extension::Ext_Zvbb) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zvkb => {((hartSupports(core_ctx, extension::Ext_Zvkb) || currentlyEnabled(core_ctx, extension::Ext_Zvbb)) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zvbc => {(hartSupports(core_ctx, extension::Ext_Zvbc) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zvknha => {(hartSupports(core_ctx, extension::Ext_Zvknha) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zvknhb => {(hartSupports(core_ctx, extension::Ext_Zvknhb) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zvksh => {(hartSupports(core_ctx, extension::Ext_Zvksh) && currentlyEnabled(core_ctx, extension::Ext_V))}
        extension::Ext_Zimop => {hartSupports(core_ctx, extension::Ext_Zimop)}
        extension::Ext_Zcmop => {(hartSupports(core_ctx, extension::Ext_Zcmop) && currentlyEnabled(core_ctx, extension::Ext_Zca))}
        _ => {panic!("Unreachable code")}
    }
}

/// virtual_memory_supported
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L149-151.
pub fn virtual_memory_supported(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (currentlyEnabled(core_ctx, extension::Ext_Sv32) || (currentlyEnabled(core_ctx, extension::Ext_Sv39) || (currentlyEnabled(core_ctx, extension::Ext_Sv48) || currentlyEnabled(core_ctx, extension::Ext_Sv57))))
}

/// lowest_supported_privLevel
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L157-158.
pub fn lowest_supported_privLevel(core_ctx: &mut Core, unit_arg: ()) -> Privilege {
    if {currentlyEnabled(core_ctx, extension::Ext_U)} {
        Privilege::User
    } else {
        Privilege::Machine
    }
}

/// have_privLevel
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L160-166.
pub fn have_privLevel(core_ctx: &mut Core, _priv_: BitVector<2>) -> bool {
    match _priv_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {currentlyEnabled(core_ctx, extension::Ext_U)}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__2 if {(b__2 == BitVector::<2>::new(0b10))} => {false}
        _ => {true}
        _ => {panic!("Unreachable code")}
    }
}

/// _update_Mstatus_FS
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_FS(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 14, 13, x)
    }
}

/// _update_Sstatus_FS
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_FS(v: Sstatus, x: BitVector<2>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 14, 13, x)
    }
}

/// _get_Sstatus_FS
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_FS(v: Sstatus) -> BitVector<2> {
    v.bits.subrange::<13, 15, 2>()
}

/// _get_Mstatus_MIE
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_MIE(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<3, 4, 1>()
}

/// _update_Mstatus_MIE
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_MIE(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 3, 3, x)
    }
}

/// _get_Mstatus_MPIE
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_MPIE(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<7, 8, 1>()
}

/// _update_Mstatus_MPIE
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_MPIE(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 7, 7, x)
    }
}

/// _get_Mstatus_MPP
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_MPP(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<11, 13, 2>()
}

/// _update_Mstatus_MPP
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_MPP(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 12, 11, x)
    }
}

/// _get_Mstatus_MPRV
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_MPRV(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<17, 18, 1>()
}

/// _update_Mstatus_MPRV
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_MPRV(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 17, 17, x)
    }
}

/// _get_Mstatus_MXR
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_MXR(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<19, 20, 1>()
}

/// _update_Mstatus_MXR
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_MXR(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 19, 19, x)
    }
}

/// _update_Sstatus_MXR
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_MXR(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 19, 19, x)
    }
}

/// _get_Sstatus_MXR
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_MXR(v: Sstatus) -> BitVector<1> {
    v.bits.subrange::<19, 20, 1>()
}

/// _get_Mstatus_SD
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SD(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<63, 64, 1>()
}

/// _update_Mstatus_SD
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SD(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 63, 63, x)
    }
}

/// _update_Sstatus_SD
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_SD(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 63, 63, x)
    }
}

/// _get_Mstatus_SIE
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SIE(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _update_Mstatus_SIE
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SIE(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _update_Sstatus_SIE
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_SIE(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _get_Sstatus_SIE
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_SIE(v: Sstatus) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _get_Mstatus_SPIE
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SPIE(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<5, 6, 1>()
}

/// _update_Mstatus_SPIE
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SPIE(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 5, 5, x)
    }
}

/// _update_Sstatus_SPIE
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_SPIE(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 5, 5, x)
    }
}

/// _get_Sstatus_SPIE
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_SPIE(v: Sstatus) -> BitVector<1> {
    v.bits.subrange::<5, 6, 1>()
}

/// _get_Mstatus_SPP
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SPP(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<8, 9, 1>()
}

/// _update_Mstatus_SPP
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SPP(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 8, 8, x)
    }
}

/// _update_Sstatus_SPP
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_SPP(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 8, 8, x)
    }
}

/// _get_Sstatus_SPP
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_SPP(v: Sstatus) -> BitVector<1> {
    v.bits.subrange::<8, 9, 1>()
}

/// _get_Mstatus_SUM
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SUM(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<18, 19, 1>()
}

/// _update_Mstatus_SUM
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_SUM(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 18, 18, x)
    }
}

/// _update_Sstatus_SUM
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_SUM(v: Sstatus, x: BitVector<1>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 18, 18, x)
    }
}

/// _get_Sstatus_SUM
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_SUM(v: Sstatus) -> BitVector<1> {
    v.bits.subrange::<18, 19, 1>()
}

/// _get_Mstatus_SXL
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_SXL(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<34, 36, 2>()
}

/// _get_Mstatus_TSR
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_TSR(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<22, 23, 1>()
}

/// _update_Mstatus_TSR
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_TSR(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 22, 22, x)
    }
}

/// _get_Mstatus_TVM
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_TVM(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<20, 21, 1>()
}

/// _update_Mstatus_TVM
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_TVM(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 20, 20, x)
    }
}

/// _get_Mstatus_TW
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_TW(v: Mstatus) -> BitVector<1> {
    v.bits.subrange::<21, 22, 1>()
}

/// _update_Mstatus_TW
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_TW(v: Mstatus, x: BitVector<1>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 21, 21, x)
    }
}

/// _get_Mstatus_UXL
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_UXL(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<32, 34, 2>()
}

/// _update_Sstatus_UXL
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_UXL(v: Sstatus, x: BitVector<2>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 33, 32, x)
    }
}

/// _get_Sstatus_UXL
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_UXL(v: Sstatus) -> BitVector<2> {
    v.bits.subrange::<32, 34, 2>()
}

/// _update_Mstatus_VS
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_VS(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 10, 9, x)
    }
}

/// _update_Sstatus_VS
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_VS(v: Sstatus, x: BitVector<2>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 10, 9, x)
    }
}

/// _get_Sstatus_VS
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_VS(v: Sstatus) -> BitVector<2> {
    v.bits.subrange::<9, 11, 2>()
}

/// _get_Mstatus_XS
/// 
/// Generated from the Sail sources.
pub fn _get_Mstatus_XS(v: Mstatus) -> BitVector<2> {
    v.bits.subrange::<15, 17, 2>()
}

/// _update_Mstatus_XS
/// 
/// Generated from the Sail sources.
pub fn _update_Mstatus_XS(v: Mstatus, x: BitVector<2>) -> Mstatus {
    Mstatus {
        bits: update_subrange_bits(v.bits, 16, 15, x)
    }
}

/// _update_Sstatus_XS
/// 
/// Generated from the Sail sources.
pub fn _update_Sstatus_XS(v: Sstatus, x: BitVector<2>) -> Sstatus {
    Sstatus {
        bits: update_subrange_bits(v.bits, 16, 15, x)
    }
}

/// _get_Sstatus_XS
/// 
/// Generated from the Sail sources.
pub fn _get_Sstatus_XS(v: Sstatus) -> BitVector<2> {
    v.bits.subrange::<15, 17, 2>()
}

/// effectivePrivilege
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L206-209.
pub fn effectivePrivilege(t: AccessType<()>, m: Mstatus, _priv_: Privilege) -> Privilege {
    if {((t != AccessType::InstructionFetch(())) && (_get_Mstatus_MPRV(m) == BitVector::<1>::new(0b1)))} {
        privLevel_of_bits(_get_Mstatus_MPP(m))
    } else {
        _priv_
    }
}

/// get_mstatus_SXL
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L211-215.
pub fn get_mstatus_SXL(m: Mstatus) -> BitVector<2> {
    _get_Mstatus_SXL(m)
}

/// get_mstatus_UXL
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L217-221.
pub fn get_mstatus_UXL(m: Mstatus) -> BitVector<2> {
    _get_Mstatus_UXL(m)
}

/// legalize_mstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L223-273.
pub fn legalize_mstatus(core_ctx: &mut Core, o: Mstatus, v: BitVector<64>) -> Mstatus {
    let v = Mk_Mstatus(v);
    let o = {
        let var_1 = {
            let var_3 = {
                let var_4 = {
                    let var_6 = {
                        let var_7 = {
                            let var_8 = {
                                let var_10 = {
                                    let var_13 = {
                                        let var_15 = {
                                            let var_16 = {
                                                let var_18 = {
                                                    let var_20 = {
                                                        let var_22 = {
                                                            let var_24 = {
                                                                let var_26 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                                                                    _get_Mstatus_TSR(v)
                                                                } else {
                                                                    BitVector::<1>::new(0b0)
                                                                };
                                                                _update_Mstatus_TSR(o, var_26)
                                                            };
                                                            let var_25 = if {currentlyEnabled(core_ctx, extension::Ext_U)} {
                                                                _get_Mstatus_TW(v)
                                                            } else {
                                                                BitVector::<1>::new(0b0)
                                                            };
                                                            _update_Mstatus_TW(var_24, var_25)
                                                        };
                                                        let var_23 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                                                            _get_Mstatus_TVM(v)
                                                        } else {
                                                            BitVector::<1>::new(0b0)
                                                        };
                                                        _update_Mstatus_TVM(var_22, var_23)
                                                    };
                                                    let var_21 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                                                        _get_Mstatus_MXR(v)
                                                    } else {
                                                        BitVector::<1>::new(0b0)
                                                    };
                                                    _update_Mstatus_MXR(var_20, var_21)
                                                };
                                                let var_19 = if {virtual_memory_supported(core_ctx, ())} {
                                                    _get_Mstatus_SUM(v)
                                                } else {
                                                    BitVector::<1>::new(0b0)
                                                };
                                                _update_Mstatus_SUM(var_18, var_19)
                                            };
                                            let var_17 = if {currentlyEnabled(core_ctx, extension::Ext_U)} {
                                                _get_Mstatus_MPRV(v)
                                            } else {
                                                BitVector::<1>::new(0b0)
                                            };
                                            _update_Mstatus_MPRV(var_16, var_17)
                                        };
                                        _update_Mstatus_XS(var_15, extStatus_to_bits(ExtStatus::Off))
                                    };
                                    let var_14 = if {hartSupports(core_ctx, extension::Ext_Zfinx)} {
                                        extStatus_to_bits(ExtStatus::Off)
                                    } else {
                                        _get_Mstatus_FS(v)
                                    };
                                    _update_Mstatus_FS(var_13, var_14)
                                };
                                let var_11 = if {have_privLevel(core_ctx, _get_Mstatus_MPP(v))} {
                                    _get_Mstatus_MPP(v)
                                } else {
                                    {
                                        let var_12 = lowest_supported_privLevel(core_ctx, ());
                                        privLevel_to_bits(var_12)
                                    }
                                };
                                _update_Mstatus_MPP(var_10, var_11)
                            };
                            let var_9 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                                _get_Mstatus_SPP(v)
                            } else {
                                BitVector::<1>::new(0b0)
                            };
                            _update_Mstatus_SPP(var_8, var_9)
                        };
                        _update_Mstatus_VS(var_7, _get_Mstatus_VS(v))
                    };
                    _update_Mstatus_MPIE(var_6, _get_Mstatus_MPIE(v))
                };
                let var_5 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                    _get_Mstatus_SPIE(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_Mstatus_SPIE(var_4, var_5)
            };
            _update_Mstatus_MIE(var_3, _get_Mstatus_MIE(v))
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
            _get_Mstatus_SIE(v)
        } else {
            BitVector::<1>::new(0b0)
        };
        _update_Mstatus_SIE(var_1, var_2)
    };
    let dirty = ((extStatus_of_bits(_get_Mstatus_FS(o)) == ExtStatus::Dirty) || ((extStatus_of_bits(_get_Mstatus_XS(o)) == ExtStatus::Dirty) || (extStatus_of_bits(_get_Mstatus_VS(o)) == ExtStatus::Dirty)));
    _update_Mstatus_SD(o, bool_to_bits(dirty))
}

/// cur_architecture
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L300-308.
pub fn cur_architecture(core_ctx: &mut Core, unit_arg: ()) -> Architecture {
    let a: arch_xlen = match core_ctx.cur_privilege {
        Privilege::Machine => {{
            let var_1 = core_ctx.misa;
            _get_Misa_MXL(var_1)
        }}
        Privilege::Supervisor => {{
            let var_2 = core_ctx.mstatus;
            get_mstatus_SXL(var_2)
        }}
        Privilege::User => {{
            let var_3 = core_ctx.mstatus;
            get_mstatus_UXL(var_3)
        }}
        _ => {panic!("Unreachable code")}
    };
    architecture_backwards(a)
}

/// in32BitMode
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L310-312.
pub fn in32BitMode(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (cur_architecture(core_ctx, ()) == Architecture::RV32)
}

/// Mk_MEnvcfg
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_MEnvcfg(v: BitVector<64>) -> MEnvcfg {
    MEnvcfg {
        bits: v
    }
}

/// _get_MEnvcfg_CBCFE
/// 
/// Generated from the Sail sources.
pub fn _get_MEnvcfg_CBCFE(v: MEnvcfg) -> BitVector<1> {
    v.bits.subrange::<6, 7, 1>()
}

/// _update_MEnvcfg_CBCFE
/// 
/// Generated from the Sail sources.
pub fn _update_MEnvcfg_CBCFE(v: MEnvcfg, x: BitVector<1>) -> MEnvcfg {
    MEnvcfg {
        bits: update_subrange_bits(v.bits, 6, 6, x)
    }
}

/// _update_SEnvcfg_CBCFE
/// 
/// Generated from the Sail sources.
pub fn _update_SEnvcfg_CBCFE(v: SEnvcfg, x: BitVector<1>) -> SEnvcfg {
    SEnvcfg {
        bits: update_subrange_bits(v.bits, 6, 6, x)
    }
}

/// _get_SEnvcfg_CBCFE
/// 
/// Generated from the Sail sources.
pub fn _get_SEnvcfg_CBCFE(v: SEnvcfg) -> BitVector<1> {
    v.bits.subrange::<6, 7, 1>()
}

/// _get_MEnvcfg_CBIE
/// 
/// Generated from the Sail sources.
pub fn _get_MEnvcfg_CBIE(v: MEnvcfg) -> BitVector<2> {
    v.bits.subrange::<4, 6, 2>()
}

/// _update_MEnvcfg_CBIE
/// 
/// Generated from the Sail sources.
pub fn _update_MEnvcfg_CBIE(v: MEnvcfg, x: BitVector<2>) -> MEnvcfg {
    MEnvcfg {
        bits: update_subrange_bits(v.bits, 5, 4, x)
    }
}

/// _update_SEnvcfg_CBIE
/// 
/// Generated from the Sail sources.
pub fn _update_SEnvcfg_CBIE(v: SEnvcfg, x: BitVector<2>) -> SEnvcfg {
    SEnvcfg {
        bits: update_subrange_bits(v.bits, 5, 4, x)
    }
}

/// _get_SEnvcfg_CBIE
/// 
/// Generated from the Sail sources.
pub fn _get_SEnvcfg_CBIE(v: SEnvcfg) -> BitVector<2> {
    v.bits.subrange::<4, 6, 2>()
}

/// _get_MEnvcfg_CBZE
/// 
/// Generated from the Sail sources.
pub fn _get_MEnvcfg_CBZE(v: MEnvcfg) -> BitVector<1> {
    v.bits.subrange::<7, 8, 1>()
}

/// _update_MEnvcfg_CBZE
/// 
/// Generated from the Sail sources.
pub fn _update_MEnvcfg_CBZE(v: MEnvcfg, x: BitVector<1>) -> MEnvcfg {
    MEnvcfg {
        bits: update_subrange_bits(v.bits, 7, 7, x)
    }
}

/// _update_SEnvcfg_CBZE
/// 
/// Generated from the Sail sources.
pub fn _update_SEnvcfg_CBZE(v: SEnvcfg, x: BitVector<1>) -> SEnvcfg {
    SEnvcfg {
        bits: update_subrange_bits(v.bits, 7, 7, x)
    }
}

/// _get_SEnvcfg_CBZE
/// 
/// Generated from the Sail sources.
pub fn _get_SEnvcfg_CBZE(v: SEnvcfg) -> BitVector<1> {
    v.bits.subrange::<7, 8, 1>()
}

/// _get_MEnvcfg_FIOM
/// 
/// Generated from the Sail sources.
pub fn _get_MEnvcfg_FIOM(v: MEnvcfg) -> BitVector<1> {
    v.bits.subrange::<0, 1, 1>()
}

/// _update_MEnvcfg_FIOM
/// 
/// Generated from the Sail sources.
pub fn _update_MEnvcfg_FIOM(v: MEnvcfg, x: BitVector<1>) -> MEnvcfg {
    MEnvcfg {
        bits: update_subrange_bits(v.bits, 0, 0, x)
    }
}

/// _update_SEnvcfg_FIOM
/// 
/// Generated from the Sail sources.
pub fn _update_SEnvcfg_FIOM(v: SEnvcfg, x: BitVector<1>) -> SEnvcfg {
    SEnvcfg {
        bits: update_subrange_bits(v.bits, 0, 0, x)
    }
}

/// _get_SEnvcfg_FIOM
/// 
/// Generated from the Sail sources.
pub fn _get_SEnvcfg_FIOM(v: SEnvcfg) -> BitVector<1> {
    v.bits.subrange::<0, 1, 1>()
}

/// _get_MEnvcfg_STCE
/// 
/// Generated from the Sail sources.
pub fn _get_MEnvcfg_STCE(v: MEnvcfg) -> BitVector<1> {
    v.bits.subrange::<63, 64, 1>()
}

/// _update_MEnvcfg_STCE
/// 
/// Generated from the Sail sources.
pub fn _update_MEnvcfg_STCE(v: MEnvcfg, x: BitVector<1>) -> MEnvcfg {
    MEnvcfg {
        bits: update_subrange_bits(v.bits, 63, 63, x)
    }
}

/// Mk_SEnvcfg
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_SEnvcfg(v: BitVector<64>) -> SEnvcfg {
    SEnvcfg {
        bits: v
    }
}

/// legalize_menvcfg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L347-357.
pub fn legalize_menvcfg(core_ctx: &mut Core, o: MEnvcfg, v: BitVector<64>) -> MEnvcfg {
    let v = Mk_MEnvcfg(v);
    {
        let var_1 = {
            let var_3 = {
                let var_5 = {
                    let var_7 = {
                        let var_9 = if {sys_enable_writable_fiom(core_ctx, ())} {
                            _get_MEnvcfg_FIOM(v)
                        } else {
                            BitVector::<1>::new(0b0)
                        };
                        _update_MEnvcfg_FIOM(o, var_9)
                    };
                    let var_8 = if {currentlyEnabled(core_ctx, extension::Ext_Zicboz)} {
                        _get_MEnvcfg_CBZE(v)
                    } else {
                        BitVector::<1>::new(0b0)
                    };
                    _update_MEnvcfg_CBZE(var_7, var_8)
                };
                let var_6 = if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} {
                    _get_MEnvcfg_CBCFE(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_MEnvcfg_CBCFE(var_5, var_6)
            };
            let var_4 = if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} {
                if {(_get_MEnvcfg_CBIE(v) != BitVector::<2>::new(0b10))} {
                    _get_MEnvcfg_CBIE(v)
                } else {
                    BitVector::<2>::new(0b00)
                }
            } else {
                BitVector::<2>::new(0b00)
            };
            _update_MEnvcfg_CBIE(var_3, var_4)
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_Sstc)} {
            _get_MEnvcfg_STCE(v)
        } else {
            BitVector::<1>::new(0b0)
        };
        _update_MEnvcfg_STCE(var_1, var_2)
    }
}

/// legalize_senvcfg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L359-368.
pub fn legalize_senvcfg(core_ctx: &mut Core, o: SEnvcfg, v: BitVector<{
    64
}>) -> SEnvcfg {
    let v = Mk_SEnvcfg(v);
    {
        let var_1 = {
            let var_3 = {
                let var_5 = {
                    let var_7 = if {sys_enable_writable_fiom(core_ctx, ())} {
                        _get_SEnvcfg_FIOM(v)
                    } else {
                        BitVector::<1>::new(0b0)
                    };
                    _update_SEnvcfg_FIOM(o, var_7)
                };
                let var_6 = if {currentlyEnabled(core_ctx, extension::Ext_Zicboz)} {
                    _get_SEnvcfg_CBZE(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_SEnvcfg_CBZE(var_5, var_6)
            };
            let var_4 = if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} {
                _get_SEnvcfg_CBCFE(v)
            } else {
                BitVector::<1>::new(0b0)
            };
            _update_SEnvcfg_CBCFE(var_3, var_4)
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} {
            if {(_get_SEnvcfg_CBIE(v) != BitVector::<2>::new(0b10))} {
                _get_SEnvcfg_CBIE(v)
            } else {
                BitVector::<2>::new(0b00)
            }
        } else {
            BitVector::<2>::new(0b00)
        };
        _update_SEnvcfg_CBIE(var_1, var_2)
    }
}

/// is_fiom_active
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L394-400.
pub fn is_fiom_active(core_ctx: &mut Core, unit_arg: ()) -> bool {
    match core_ctx.cur_privilege {
        Privilege::Machine => {false}
        Privilege::Supervisor => {({
            let var_1 = core_ctx.menvcfg;
            _get_MEnvcfg_FIOM(var_1)
        } == BitVector::<1>::new(0b1))}
        Privilege::User => {(({
            let var_3 = core_ctx.menvcfg;
            _get_MEnvcfg_FIOM(var_3)
        } | {
            let var_2 = core_ctx.senvcfg;
            _get_SEnvcfg_FIOM(var_2)
        }) == BitVector::<1>::new(0b1))}
        _ => {panic!("Unreachable code")}
    }
}

/// Mk_Minterrupts
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Minterrupts(v: BitVector<64>) -> Minterrupts {
    Minterrupts {
        bits: v
    }
}

/// _get_Minterrupts_MEI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_MEI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<11, 12, 1>()
}

/// _update_Minterrupts_MEI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_MEI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 11, 11, x)
    }
}

/// _get_Minterrupts_MSI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_MSI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<3, 4, 1>()
}

/// _update_Minterrupts_MSI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_MSI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 3, 3, x)
    }
}

/// _get_Minterrupts_MTI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_MTI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<7, 8, 1>()
}

/// _update_Minterrupts_MTI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_MTI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 7, 7, x)
    }
}

/// _get_Minterrupts_SEI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_SEI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<9, 10, 1>()
}

/// _update_Minterrupts_SEI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_SEI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 9, 9, x)
    }
}

/// _update_Sinterrupts_SEI
/// 
/// Generated from the Sail sources.
pub fn _update_Sinterrupts_SEI(v: Sinterrupts, x: BitVector<1>) -> Sinterrupts {
    Sinterrupts {
        bits: update_subrange_bits(v.bits, 9, 9, x)
    }
}

/// _get_Sinterrupts_SEI
/// 
/// Generated from the Sail sources.
pub fn _get_Sinterrupts_SEI(v: Sinterrupts) -> BitVector<1> {
    v.bits.subrange::<9, 10, 1>()
}

/// _get_Minterrupts_SSI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_SSI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _update_Minterrupts_SSI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_SSI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _update_Sinterrupts_SSI
/// 
/// Generated from the Sail sources.
pub fn _update_Sinterrupts_SSI(v: Sinterrupts, x: BitVector<1>) -> Sinterrupts {
    Sinterrupts {
        bits: update_subrange_bits(v.bits, 1, 1, x)
    }
}

/// _get_Sinterrupts_SSI
/// 
/// Generated from the Sail sources.
pub fn _get_Sinterrupts_SSI(v: Sinterrupts) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// _get_Minterrupts_STI
/// 
/// Generated from the Sail sources.
pub fn _get_Minterrupts_STI(v: Minterrupts) -> BitVector<1> {
    v.bits.subrange::<5, 6, 1>()
}

/// _update_Minterrupts_STI
/// 
/// Generated from the Sail sources.
pub fn _update_Minterrupts_STI(v: Minterrupts, x: BitVector<1>) -> Minterrupts {
    Minterrupts {
        bits: update_subrange_bits(v.bits, 5, 5, x)
    }
}

/// _update_Sinterrupts_STI
/// 
/// Generated from the Sail sources.
pub fn _update_Sinterrupts_STI(v: Sinterrupts, x: BitVector<1>) -> Sinterrupts {
    Sinterrupts {
        bits: update_subrange_bits(v.bits, 5, 5, x)
    }
}

/// _get_Sinterrupts_STI
/// 
/// Generated from the Sail sources.
pub fn _get_Sinterrupts_STI(v: Sinterrupts) -> BitVector<1> {
    v.bits.subrange::<5, 6, 1>()
}

/// legalize_mip
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L415-427.
pub fn legalize_mip(core_ctx: &mut Core, o: Minterrupts, v: BitVector<{
    64
}>) -> Minterrupts {
    let v = Mk_Minterrupts(v);
    {
        let var_1 = {
            let var_4 = {
                let var_6 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                    _get_Minterrupts_SEI(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_Minterrupts_SEI(o, var_6)
            };
            let var_5 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                _get_Minterrupts_SSI(v)
            } else {
                BitVector::<1>::new(0b0)
            };
            _update_Minterrupts_SSI(var_4, var_5)
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
            if {(currentlyEnabled(core_ctx, extension::Ext_Sstc) && ({
                let var_3 = core_ctx.menvcfg;
                _get_MEnvcfg_STCE(var_3)
            } == BitVector::<1>::new(0b1)))} {
                _get_Minterrupts_STI(o)
            } else {
                _get_Minterrupts_STI(v)
            }
        } else {
            BitVector::<1>::new(0b0)
        };
        _update_Minterrupts_STI(var_1, var_2)
    }
}

/// legalize_mie
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L429-439.
pub fn legalize_mie(core_ctx: &mut Core, o: Minterrupts, v: BitVector<{
    64
}>) -> Minterrupts {
    let v = Mk_Minterrupts(v);
    {
        let var_1 = {
            let var_3 = {
                let var_5 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                    _get_Minterrupts_SEI(v)
                } else {
                    BitVector::<1>::new(0b0)
                };
                _update_Minterrupts_SEI(_update_Minterrupts_MSI(_update_Minterrupts_MTI(_update_Minterrupts_MEI(o, _get_Minterrupts_MEI(v)), _get_Minterrupts_MTI(v)), _get_Minterrupts_MSI(v)), var_5)
            };
            let var_4 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                _get_Minterrupts_STI(v)
            } else {
                BitVector::<1>::new(0b0)
            };
            _update_Minterrupts_STI(var_3, var_4)
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
            _get_Minterrupts_SSI(v)
        } else {
            BitVector::<1>::new(0b0)
        };
        _update_Minterrupts_SSI(var_1, var_2)
    }
}

/// legalize_mideleg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L441-445.
pub fn legalize_mideleg(o: Minterrupts, v: BitVector<{
    64
}>) -> Minterrupts {
    _update_Minterrupts_MSI(_update_Minterrupts_MTI(_update_Minterrupts_MEI(Mk_Minterrupts(v), BitVector::<1>::new(0b0)), BitVector::<1>::new(0b0)), BitVector::<1>::new(0b0))
}

/// Mk_Medeleg
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Medeleg(v: BitVector<64>) -> Medeleg {
    Medeleg {
        bits: v
    }
}

/// _update_Medeleg_MEnvCall
/// 
/// Generated from the Sail sources.
pub fn _update_Medeleg_MEnvCall(v: Medeleg, x: BitVector<1>) -> Medeleg {
    Medeleg {
        bits: update_subrange_bits(v.bits, 11, 11, x)
    }
}

/// legalize_medeleg
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L466-469.
pub fn legalize_medeleg(o: Medeleg, v: BitVector<64>) -> Medeleg {
    _update_Medeleg_MEnvCall(Mk_Medeleg(v), BitVector::<1>::new(0b0))
}

/// Mk_Mtvec
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Mtvec(v: BitVector<64>) -> Mtvec {
    Mtvec {
        bits: v
    }
}

/// _get_Mtvec_Base
/// 
/// Generated from the Sail sources.
pub fn _get_Mtvec_Base(v: Mtvec) -> BitVector<62> {
    v.bits.subrange::<2, 64, 62>()
}

/// _get_Mtvec_Mode
/// 
/// Generated from the Sail sources.
pub fn _get_Mtvec_Mode(v: Mtvec) -> BitVector<2> {
    v.bits.subrange::<0, 2, 2>()
}

/// _update_Mtvec_Mode
/// 
/// Generated from the Sail sources.
pub fn _update_Mtvec_Mode(v: Mtvec, x: BitVector<2>) -> Mtvec {
    Mtvec {
        bits: update_subrange_bits(v.bits, 1, 0, x)
    }
}

/// _get_Satp32_Mode
/// 
/// Generated from the Sail sources.
pub fn _get_Satp32_Mode(v: Satp32) -> BitVector<1> {
    v.bits.subrange::<31, 32, 1>()
}

/// _get_Satp64_Mode
/// 
/// Generated from the Sail sources.
pub fn _get_Satp64_Mode(v: Satp64) -> BitVector<4> {
    v.bits.subrange::<60, 64, 4>()
}

/// legalize_tvec
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L509-516.
pub fn legalize_tvec(o: Mtvec, v: BitVector<{
    64
}>) -> Mtvec {
    let v = Mk_Mtvec(v);
    match trapVectorMode_of_bits(_get_Mtvec_Mode(v)) {
        TrapVectorMode::TV_Direct => {v}
        TrapVectorMode::TV_Vector => {v}
        _ => {_update_Mtvec_Mode(v, _get_Mtvec_Mode(o))}
        _ => {panic!("Unreachable code")}
    }
}

/// _get_Mcause_Cause
/// 
/// Generated from the Sail sources.
pub fn _get_Mcause_Cause(v: Mcause) -> BitVector<63> {
    v.bits.subrange::<0, 63, 63>()
}

/// _get_Mcause_IsInterrupt
/// 
/// Generated from the Sail sources.
pub fn _get_Mcause_IsInterrupt(v: Mcause) -> BitVector<1> {
    v.bits.subrange::<63, 64, 1>()
}

/// tvec_addr
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L529-538.
pub fn tvec_addr(m: Mtvec, c: Mcause) -> Option<BitVector<{
    64
}>> {
    let base: xlenbits = bitvector_concat::<62, 2, 64>(_get_Mtvec_Base(m), BitVector::<2>::new(0b00));
    match trapVectorMode_of_bits(_get_Mtvec_Mode(m)) {
        TrapVectorMode::TV_Direct => {Some(base)}
        TrapVectorMode::TV_Vector => {if {(_get_Mcause_IsInterrupt(c) == BitVector::<1>::new(0b1))} {
            Some(base.wrapped_add((_get_Mcause_Cause(c).zero_extend::<64>() << 2)))
        } else {
            Some(base)
        }}
        TrapVectorMode::TV_Reserved => {None}
        _ => {panic!("Unreachable code")}
    }
}

/// legalize_xepc
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L547-552.
pub fn legalize_xepc(core_ctx: &mut Core, v: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    if {hartSupports(core_ctx, extension::Ext_C)} {
        bitvector_update(v, 0, false)
    } else {
        update_subrange_bits(v, 1, 0, zeros::<2>(2))
    }
}

/// align_pc
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L556-560.
pub fn align_pc(core_ctx: &mut Core, addr: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    if {({
        let var_1 = core_ctx.misa;
        _get_Misa_C(var_1)
    } == BitVector::<1>::new(0b1))} {
        bitvector_update(addr, 0, false)
    } else {
        update_subrange_bits(addr, 1, 0, zeros::<2>(2))
    }
}

/// Mk_Counteren
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Counteren(v: BitVector<32>) -> Counteren {
    Counteren {
        bits: v
    }
}

/// _get_Counteren_TM
/// 
/// Generated from the Sail sources.
pub fn _get_Counteren_TM(v: Counteren) -> BitVector<1> {
    v.bits.subrange::<1, 2, 1>()
}

/// legalize_scounteren
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L589-592.
pub fn legalize_scounteren(core_ctx: &mut Core, c: Counteren, v: BitVector<{
    64
}>) -> Counteren {
    let supported_counters = bitvector_concat::<29, 3, 32>(subrange_bits::<_, 29>(sys_writable_hpm_counters(core_ctx, ()), 31, 3), BitVector::<3>::new(0b111));
    Mk_Counteren((v.subrange::<0, 32, 32>() & supported_counters))
}

/// legalize_mcounteren
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L601-604.
pub fn legalize_mcounteren(core_ctx: &mut Core, c: Counteren, v: BitVector<{
    64
}>) -> Counteren {
    let supported_counters = bitvector_concat::<29, 3, 32>(subrange_bits::<_, 29>(sys_writable_hpm_counters(core_ctx, ()), 31, 3), BitVector::<3>::new(0b111));
    Mk_Counteren((v.subrange::<0, 32, 32>() & supported_counters))
}

/// Mk_Counterin
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Counterin(v: BitVector<32>) -> Counterin {
    Counterin {
        bits: v
    }
}

/// legalize_mcountinhibit
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L620-624.
pub fn legalize_mcountinhibit(core_ctx: &mut Core, c: Counterin, v: BitVector<{
    64
}>) -> Counterin {
    let supported_counters = bitvector_concat::<29, 3, 32>(subrange_bits::<_, 29>(sys_writable_hpm_counters(core_ctx, ()), 31, 3), BitVector::<3>::new(0b101));
    Mk_Counterin((v.subrange::<0, 32, 32>() & supported_counters))
}

/// Mk_Sstatus
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Sstatus(v: BitVector<64>) -> Sstatus {
    Sstatus {
        bits: v
    }
}

/// lower_mstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L697-714.
pub fn lower_mstatus(m: Mstatus) -> Sstatus {
    let s = Mk_Sstatus(zeros::<64>(64));
    _update_Sstatus_SIE(_update_Sstatus_SPIE(_update_Sstatus_SPP(_update_Sstatus_VS(_update_Sstatus_FS(_update_Sstatus_XS(_update_Sstatus_SUM(_update_Sstatus_MXR(_update_Sstatus_UXL(_update_Sstatus_SD(s, _get_Mstatus_SD(m)), _get_Mstatus_UXL(m)), _get_Mstatus_MXR(m)), _get_Mstatus_SUM(m)), _get_Mstatus_XS(m)), _get_Mstatus_FS(m)), _get_Mstatus_VS(m)), _get_Mstatus_SPP(m)), _get_Mstatus_SPIE(m)), _get_Mstatus_SIE(m))
}

/// lift_sstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L716-734.
pub fn lift_sstatus(m: Mstatus, s: Sstatus) -> Mstatus {
    let dirty = ((extStatus_of_bits(_get_Sstatus_FS(s)) == ExtStatus::Dirty) || ((extStatus_of_bits(_get_Sstatus_XS(s)) == ExtStatus::Dirty) || (extStatus_of_bits(_get_Sstatus_VS(s)) == ExtStatus::Dirty)));
    _update_Mstatus_SIE(_update_Mstatus_SPIE(_update_Mstatus_SPP(_update_Mstatus_VS(_update_Mstatus_FS(_update_Mstatus_XS(_update_Mstatus_SUM(_update_Mstatus_MXR(_update_Mstatus_UXL(_update_Mstatus_SD(m, bool_to_bits(dirty)), _get_Sstatus_UXL(s)), _get_Sstatus_MXR(s)), _get_Sstatus_SUM(s)), _get_Sstatus_XS(s)), _get_Sstatus_FS(s)), _get_Sstatus_VS(s)), _get_Sstatus_SPP(s)), _get_Sstatus_SPIE(s)), _get_Sstatus_SIE(s))
}

/// legalize_sstatus
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L736-738.
pub fn legalize_sstatus(core_ctx: &mut Core, m: Mstatus, v: BitVector<{
    64
}>) -> Mstatus {
    legalize_mstatus(core_ctx, m, lift_sstatus(m, Mk_Sstatus(v.zero_extend::<64>())).bits)
}

/// Mk_Sinterrupts
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Sinterrupts(v: BitVector<64>) -> Sinterrupts {
    Sinterrupts {
        bits: v
    }
}

/// lower_mip
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L756-764.
pub fn lower_mip(m: Minterrupts, d: Minterrupts) -> Sinterrupts {
    let s: Sinterrupts = Mk_Sinterrupts(zeros::<64>(64));
    _update_Sinterrupts_SSI(_update_Sinterrupts_STI(_update_Sinterrupts_SEI(s, (_get_Minterrupts_SEI(m) & _get_Minterrupts_SEI(d))), (_get_Minterrupts_STI(m) & _get_Minterrupts_STI(d))), (_get_Minterrupts_SSI(m) & _get_Minterrupts_SSI(d)))
}

/// lower_mie
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L767-775.
pub fn lower_mie(m: Minterrupts, d: Minterrupts) -> Sinterrupts {
    let s: Sinterrupts = Mk_Sinterrupts(zeros::<64>(64));
    _update_Sinterrupts_SSI(_update_Sinterrupts_STI(_update_Sinterrupts_SEI(s, (_get_Minterrupts_SEI(m) & _get_Minterrupts_SEI(d))), (_get_Minterrupts_STI(m) & _get_Minterrupts_STI(d))), (_get_Minterrupts_SSI(m) & _get_Minterrupts_SSI(d)))
}

/// lift_sip
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L778-782.
pub fn lift_sip(o: Minterrupts, d: Minterrupts, s: Sinterrupts) -> Minterrupts {
    let m: Minterrupts = o;
    let m = if {(_get_Minterrupts_SSI(d) == BitVector::<1>::new(0b1))} {
        _update_Minterrupts_SSI(m, _get_Sinterrupts_SSI(s))
    } else {
        m
    };
    m
}

/// legalize_sip
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L784-786.
pub fn legalize_sip(m: Minterrupts, d: Minterrupts, v: BitVector<{
    64
}>) -> Minterrupts {
    lift_sip(m, d, Mk_Sinterrupts(v))
}

/// lift_sie
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L796-803.
pub fn lift_sie(o: Minterrupts, d: Minterrupts, s: Sinterrupts) -> Minterrupts {
    let m: Minterrupts = o;
    {
        let var_1 = {
            let var_3 = {
                let var_5 = if {(_get_Minterrupts_SEI(d) == BitVector::<1>::new(0b1))} {
                    _get_Sinterrupts_SEI(s)
                } else {
                    _get_Minterrupts_SEI(m)
                };
                _update_Minterrupts_SEI(m, var_5)
            };
            let var_4 = if {(_get_Minterrupts_STI(d) == BitVector::<1>::new(0b1))} {
                _get_Sinterrupts_STI(s)
            } else {
                _get_Minterrupts_STI(m)
            };
            _update_Minterrupts_STI(var_3, var_4)
        };
        let var_2 = if {(_get_Minterrupts_SSI(d) == BitVector::<1>::new(0b1))} {
            _get_Sinterrupts_SSI(s)
        } else {
            _get_Minterrupts_SSI(m)
        };
        _update_Minterrupts_SSI(var_1, var_2)
    }
}

/// legalize_sie
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L805-807.
pub fn legalize_sie(m: Minterrupts, d: Minterrupts, v: BitVector<{
    64
}>) -> Minterrupts {
    lift_sie(m, d, Mk_Sinterrupts(v))
}

/// Mk_Satp64
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Satp64(v: BitVector<64>) -> Satp64 {
    Satp64 {
        bits: v
    }
}

/// Mk_Satp32
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Satp32(v: BitVector<32>) -> Satp32 {
    Satp32 {
        bits: v
    }
}

/// legalize_satp
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L858-888.
pub fn legalize_satp(core_ctx: &mut Core, arch: Architecture, prev_value: BitVector<{
    64
}>, written_value: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    let s = Mk_Satp64(written_value);
    match satpMode_of_bits(arch, _get_Satp64_Mode(s)) {
        None => {prev_value}
        Some(Sv_mode) => {match Sv_mode {
            SATPMode::Bare if {currentlyEnabled(core_ctx, extension::Ext_Svbare)} => {s.bits}
            SATPMode::Sv39 if {currentlyEnabled(core_ctx, extension::Ext_Sv39)} => {s.bits}
            SATPMode::Sv48 if {currentlyEnabled(core_ctx, extension::Ext_Sv48)} => {s.bits}
            SATPMode::Sv57 if {currentlyEnabled(core_ctx, extension::Ext_Sv57)} => {s.bits}
            _ => {prev_value}
            _ => {panic!("Unreachable code")}
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// get_vlenb
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L919-921.
pub fn get_vlenb(unit_arg: ()) -> BitVector<{
    64
}> {
    to_bits::<64>(64, (8 / 8))
}

/// _get_Vtype_vlmul
/// 
/// Generated from the Sail sources.
pub fn _get_Vtype_vlmul(v: Vtype) -> BitVector<3> {
    v.bits.subrange::<0, 3, 3>()
}

/// _get_Vtype_vsew
/// 
/// Generated from the Sail sources.
pub fn _get_Vtype_vsew(v: Vtype) -> BitVector<3> {
    v.bits.subrange::<3, 6, 3>()
}

/// get_sew_pow
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L936-945.
pub fn get_sew_pow(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    let SEW_pow: i128 = match {
        let var_1 = core_ctx.vtype;
        _get_Vtype_vsew(var_1)
    } {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {3}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {4}
        b__2 if {(b__2 == BitVector::<3>::new(0b010))} => {5}
        b__3 if {(b__3 == BitVector::<3>::new(0b011))} => {6}
        _ => {{
            assert!(false, "invalid vsew field in vtype");
            panic!("exit")
        }}
        _ => {panic!("Unreachable code")}
    };
    SEW_pow
}

/// get_sew
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L948-956.
pub fn get_sew(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    match get_sew_pow(core_ctx, ()) {
        l__547 if {(l__547 == 3)} => {8}
        l__548 if {(l__548 == 4)} => {16}
        l__549 if {(l__549 == 5)} => {32}
        l__550 if {(l__550 == 6)} => {64}
        _ => {{
            panic!("{}, l {}: {}", "riscv_sys_regs.sail", 954, "invalid SEW");
            8
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// get_lmul_pow
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L972-983.
pub fn get_lmul_pow(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    match {
        let var_1 = core_ctx.vtype;
        _get_Vtype_vlmul(var_1)
    } {
        b__0 if {(b__0 == BitVector::<3>::new(0b101))} => {-3}
        b__1 if {(b__1 == BitVector::<3>::new(0b110))} => {-2}
        b__2 if {(b__2 == BitVector::<3>::new(0b111))} => {-1}
        b__3 if {(b__3 == BitVector::<3>::new(0b000))} => {0}
        b__4 if {(b__4 == BitVector::<3>::new(0b001))} => {1}
        b__5 if {(b__5 == BitVector::<3>::new(0b010))} => {2}
        b__6 if {(b__6 == BitVector::<3>::new(0b011))} => {3}
        _ => {{
            assert!(false, "invalid vlmul field in vtype");
            panic!("exit")
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// agtype
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L985.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum agtype {
    UNDISTURBED,
    AGNOSTIC
}

/// PmpAddrMatchType
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L11.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum PmpAddrMatchType {
    OFF,
    TOR,
    NA4,
    NAPOT
}

/// pmpAddrMatchType_of_bits
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L14-21.
pub fn pmpAddrMatchType_of_bits(bs: BitVector<2>) -> PmpAddrMatchType {
    match bs {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {PmpAddrMatchType::OFF}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {PmpAddrMatchType::TOR}
        b__2 if {(b__2 == BitVector::<2>::new(0b10))} => {PmpAddrMatchType::NA4}
        _ => {PmpAddrMatchType::NAPOT}
        _ => {panic!("Unreachable code")}
    }
}

/// pmpAddrMatchType_to_bits
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L24-31.
pub fn pmpAddrMatchType_to_bits(bs: PmpAddrMatchType) -> BitVector<2> {
    match bs {
        PmpAddrMatchType::OFF => {BitVector::<2>::new(0b00)}
        PmpAddrMatchType::TOR => {BitVector::<2>::new(0b01)}
        PmpAddrMatchType::NA4 => {BitVector::<2>::new(0b10)}
        PmpAddrMatchType::NAPOT => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// Mk_Pmpcfg_ent
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_Pmpcfg_ent(v: BitVector<8>) -> Pmpcfg_ent {
    Pmpcfg_ent {
        bits: v
    }
}

/// pmpReadCfgReg
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L48-67.
pub fn pmpReadCfgReg(core_ctx: &mut Core, n: i128) -> BitVector<{
    64
}> {
    assert!((((n as usize) % (2 as usize)) == 0), "Unexpected pmp config reg read");
    bitvector_concat::<8, 56, 64>(core_ctx.pmpcfg_n[(((n * 4) + 7) as usize)].bits, bitvector_concat::<8, 48, 56>(core_ctx.pmpcfg_n[(((n * 4) + 6) as usize)].bits, bitvector_concat::<8, 40, 48>(core_ctx.pmpcfg_n[(((n * 4) + 5) as usize)].bits, bitvector_concat::<8, 32, 40>(core_ctx.pmpcfg_n[(((n * 4) + 4) as usize)].bits, bitvector_concat::<8, 24, 32>(core_ctx.pmpcfg_n[(((n * 4) + 3) as usize)].bits, bitvector_concat::<8, 16, 24>(core_ctx.pmpcfg_n[(((n * 4) + 2) as usize)].bits, bitvector_concat::<8, 8, 16>(core_ctx.pmpcfg_n[(((n * 4) + 1) as usize)].bits, core_ctx.pmpcfg_n[(((n * 4) + 0) as usize)].bits)))))))
}

/// pmpReadAddrReg
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L69-89.
pub fn pmpReadAddrReg(core_ctx: &mut Core, n: i128) -> BitVector<{
    64
}> {
    let G = sys_pmp_grain(core_ctx, ());
    let match_type = _get_Pmpcfg_ent_A(core_ctx.pmpcfg_n[(n as usize)]);
    let addr = core_ctx.pmpaddr_n[(n as usize)];
    match bitvector_access(match_type, 1) {
        true if {(G >= 2)} => {{
            let mask: xlenbits = ones::<64>(min_int((G - 1), 64)).zero_extend::<64>();
            (addr | mask)
        }}
        false if {(G >= 1)} => {{
            let mask: xlenbits = ones::<64>(min_int(G, 64)).zero_extend::<64>();
            (addr & !(mask))
        }}
        _ => {addr}
        _ => {panic!("Unreachable code")}
    }
}

/// pmpLocked
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L92-93.
pub fn pmpLocked(cfg: Pmpcfg_ent) -> bool {
    (_get_Pmpcfg_ent_L(cfg) == BitVector::<1>::new(0b1))
}

/// pmpTORLocked
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L95-96.
pub fn pmpTORLocked(cfg: Pmpcfg_ent) -> bool {
    ((_get_Pmpcfg_ent_L(cfg) == BitVector::<1>::new(0b1)) && (pmpAddrMatchType_of_bits(_get_Pmpcfg_ent_A(cfg)) == PmpAddrMatchType::TOR))
}

/// pmpWriteCfg
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L98-117.
pub fn pmpWriteCfg(core_ctx: &mut Core, n: i128, cfg: Pmpcfg_ent, v: BitVector<8>) -> Pmpcfg_ent {
    if {pmpLocked(cfg)} {
        cfg
    } else {
        let cfg = Mk_Pmpcfg_ent((v & BitVector::<8>::new(0b10011111)));
        let cfg = if {((_get_Pmpcfg_ent_W(cfg) == BitVector::<1>::new(0b1)) && (_get_Pmpcfg_ent_R(cfg) == BitVector::<1>::new(0b0)))} {
            _update_Pmpcfg_ent_R(_update_Pmpcfg_ent_W(_update_Pmpcfg_ent_X(cfg, BitVector::<1>::new(0b0)), BitVector::<1>::new(0b0)), BitVector::<1>::new(0b0))
        } else {
            cfg
        };
        let cfg = if {((sys_pmp_grain(core_ctx, ()) >= 1) && (pmpAddrMatchType_of_bits(_get_Pmpcfg_ent_A(cfg)) == PmpAddrMatchType::NA4))} {
            _update_Pmpcfg_ent_A(cfg, pmpAddrMatchType_to_bits(PmpAddrMatchType::OFF))
        } else {
            cfg
        };
        cfg
    }
}

/// pmpWriteCfgReg
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L119-134.
pub fn pmpWriteCfgReg(core_ctx: &mut Core, n: i128, v: BitVector<{
    64
}>) {
    assert!((((n as usize) % (2 as usize)) == 0), "Unexpected pmp config reg write");
    for i in 0..=7 {
        let idx = ((n * 4) + i);
        core_ctx.pmpcfg_n[(idx as usize)] = pmpWriteCfg(core_ctx, idx, core_ctx.pmpcfg_n[(idx as usize)], subrange_bits(v, ((8 * i) + 7), (8 * i)))
    }
}

/// pmpWriteAddr
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L136-139.
pub fn pmpWriteAddr(locked: bool, tor_locked: bool, reg: BitVector<{
    64
}>, v: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    if {(locked || tor_locked)} {
        reg
    } else {
        v.subrange::<0, 54, 54>().zero_extend::<64>()
    }
}

/// pmpWriteAddrReg
/// 
/// Generated from the Sail sources at `riscv_pmp_regs.sail` L141-148.
pub fn pmpWriteAddrReg(core_ctx: &mut Core, n: i128, v: BitVector<{
    64
}>) {
    core_ctx.pmpaddr_n[(n as usize)] = {
        let var_1 = if {((n + 1) < 64)} {
            pmpTORLocked(core_ctx.pmpcfg_n[((n + 1) as usize)])
        } else {
            false
        };
        pmpWriteAddr(pmpLocked(core_ctx.pmpcfg_n[(n as usize)]), var_1, core_ctx.pmpaddr_n[(n as usize)], v)
    }
}

/// pmpCheckRWX
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L13-19.
pub fn pmpCheckRWX(ent: Pmpcfg_ent, acc: AccessType<()>) -> bool {
    match acc {
        AccessType::Read(_) => {(_get_Pmpcfg_ent_R(ent) == BitVector::<1>::new(0b1))}
        AccessType::Write(_) => {(_get_Pmpcfg_ent_W(ent) == BitVector::<1>::new(0b1))}
        AccessType::ReadWrite(_) => {((_get_Pmpcfg_ent_R(ent) == BitVector::<1>::new(0b1)) && (_get_Pmpcfg_ent_W(ent) == BitVector::<1>::new(0b1)))}
        AccessType::InstructionFetch(()) => {(_get_Pmpcfg_ent_X(ent) == BitVector::<1>::new(0b1))}
        _ => {panic!("Unreachable code")}
    }
}

/// pmpAddrMatch
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L24.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum pmpAddrMatch {
    PMP_NoMatch,
    PMP_PartialMatch,
    PMP_Match
}

/// pmpRangeMatch
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L29-39.
pub fn pmpRangeMatch(begin: nat, end_: nat, addr: nat, width: nat) -> pmpAddrMatch {
    if {(((addr + width) <= begin) || (end_ <= addr))} {
        pmpAddrMatch::PMP_NoMatch
    } else if {((begin <= addr) && ((addr + width) <= end_))} {
        pmpAddrMatch::PMP_Match
    } else {
        pmpAddrMatch::PMP_PartialMatch
    }
}

/// pmpMatchAddr
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L41-80.
pub fn pmpMatchAddr(core_ctx: &mut Core, physaddr::Physaddr(addr): physaddr, width: BitVector<{
    64
}>, ent: Pmpcfg_ent, pmpaddr: BitVector<{
    64
}>, prev_pmpaddr: BitVector<{
    64
}>) -> pmpAddrMatch {
    let addr = addr.unsigned();
    let width = width.unsigned();
    match pmpAddrMatchType_of_bits(_get_Pmpcfg_ent_A(ent)) {
        PmpAddrMatchType::OFF => {pmpAddrMatch::PMP_NoMatch}
        PmpAddrMatchType::TOR => {{
            if {_operator_biggerequal_u_(prev_pmpaddr, pmpaddr)} {
                pmpAddrMatch::PMP_NoMatch
            } else {
                pmpRangeMatch((((prev_pmpaddr.unsigned() as i128) * (4 as i128)) as u128), (((pmpaddr.unsigned() as i128) * (4 as i128)) as u128), (addr as u128), (width as u128))
            }
        }}
        PmpAddrMatchType::NA4 => {{
            assert!((sys_pmp_grain(core_ctx, ()) < 1), "NA4 cannot be selected when PMP grain G >= 1.");
            let begin = ((pmpaddr.unsigned() as i128) * (4 as i128));
            pmpRangeMatch((begin as u128), ((begin + 4) as u128), (addr as u128), (width as u128))
        }}
        PmpAddrMatchType::NAPOT => {{
            let mask = (pmpaddr ^ (pmpaddr + 1));
            let begin_words = (pmpaddr & !(mask)).unsigned();
            let end_words = ((begin_words + mask.unsigned()) + 1);
            pmpRangeMatch(((begin_words * 4) as u128), ((end_words * 4) as u128), (addr as u128), (width as u128))
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// pmpMatch
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L82.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum pmpMatch {
    PMP_Success,
    PMP_Continue,
    PMP_Fail
}

/// pmpMatchEntry
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L84-93.
pub fn pmpMatchEntry(core_ctx: &mut Core, addr: physaddr, width: BitVector<{
    64
}>, acc: AccessType<()>, _priv_: Privilege, ent: Pmpcfg_ent, pmpaddr: BitVector<{
    64
}>, prev_pmpaddr: BitVector<{
    64
}>) -> pmpMatch {
    match pmpMatchAddr(core_ctx, addr, width, ent, pmpaddr, prev_pmpaddr) {
        pmpAddrMatch::PMP_NoMatch => {pmpMatch::PMP_Continue}
        pmpAddrMatch::PMP_PartialMatch => {pmpMatch::PMP_Fail}
        pmpAddrMatch::PMP_Match => {if {(pmpCheckRWX(ent, acc) || ((_priv_ == Privilege::Machine) && !(pmpLocked(ent))))} {
            pmpMatch::PMP_Success
        } else {
            pmpMatch::PMP_Fail
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// accessToFault
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L97-103.
pub fn accessToFault(acc: AccessType<()>) -> ExceptionType {
    match acc {
        AccessType::Read(_) => {ExceptionType::E_Load_Access_Fault(())}
        AccessType::Write(_) => {ExceptionType::E_SAMO_Access_Fault(())}
        AccessType::ReadWrite(_) => {ExceptionType::E_SAMO_Access_Fault(())}
        AccessType::InstructionFetch(()) => {ExceptionType::E_Fetch_Access_Fault(())}
        _ => {panic!("Unreachable code")}
    }
}

/// pmpCheck
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L105-118.
pub fn pmpCheck(core_ctx: &mut Core, addr: physaddr, width: i128, acc: AccessType<()>, _priv_: Privilege) -> Option<ExceptionType> {
    let width: xlenbits = to_bits::<64>(64, width);
    for i in 0..=63 {
        let prev_pmpaddr = if {(i > 0)} {
            pmpReadAddrReg(core_ctx, (i - 1))
        } else {
            zeros::<64>(64)
        };
        match {
            let var_1 = pmpReadAddrReg(core_ctx, i);
            pmpMatchEntry(core_ctx, addr, width, acc, _priv_, core_ctx.pmpcfg_n[(i as usize)], var_1, prev_pmpaddr)
        } {
            pmpMatch::PMP_Success => {{
                return None;
            }}
            pmpMatch::PMP_Fail => {{
                return Some(accessToFault(acc));
            }}
            pmpMatch::PMP_Continue => {()}
            _ => {panic!("Unreachable code")}
        }
    };
    if {(_priv_ == Privilege::Machine)} {
        None
    } else {
        Some(accessToFault(acc))
    }
}

/// reset_pmp
/// 
/// Generated from the Sail sources at `riscv_pmp_control.sail` L120-131.
pub fn reset_pmp(core_ctx: &mut Core, unit_arg: ()) {
    assert!(((sys_pmp_count(core_ctx, ()) == 0) || (((sys_pmp_count(core_ctx, ()) == 16) || ((sys_pmp_count(core_ctx, ()) == 64) as bool)) as bool)), "sys_pmp_count() must be 0, 16, or 64");
    for i in 0..=63 {
        core_ctx.pmpcfg_n[(i as usize)] = _update_Pmpcfg_ent_L(_update_Pmpcfg_ent_A(core_ctx.pmpcfg_n[(i as usize)], pmpAddrMatchType_to_bits(PmpAddrMatchType::OFF)), BitVector::<1>::new(0b0))
    }
}

/// ext_check_CSR
/// 
/// Generated from the Sail sources at `riscv_ext_regs.sail` L18.
pub const fn ext_check_CSR(csrno: BitVector<12>, p: Privilege, isWrite: bool) -> bool {
    true
}

/// Ext_FetchAddr_Check
/// 
/// Generated from the Sail sources at `riscv_addr_checks_common.sail` L17-20.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Ext_FetchAddr_Check<A> {
    Ext_FetchAddr_OK(virtaddr),
    Ext_FetchAddr_Error(A)
}

/// Ext_ControlAddr_Check
/// 
/// Generated from the Sail sources at `riscv_addr_checks_common.sail` L22-25.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Ext_ControlAddr_Check<A> {
    Ext_ControlAddr_OK(virtaddr),
    Ext_ControlAddr_Error(A)
}

/// Ext_DataAddr_Check
/// 
/// Generated from the Sail sources at `riscv_addr_checks_common.sail` L27-30.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Ext_DataAddr_Check<A> {
    Ext_DataAddr_OK(virtaddr),
    Ext_DataAddr_Error(A)
}

/// Ext_PhysAddr_Check
/// 
/// Generated from the Sail sources at `riscv_addr_checks_common.sail` L32-35.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Ext_PhysAddr_Check {
    Ext_PhysAddr_OK(()),
    Ext_PhysAddr_Error(ExceptionType)
}

pub type ext_fetch_addr_error = ();

pub type ext_control_addr_error = ();

/// ext_control_check_addr
/// 
/// Generated from the Sail sources at `riscv_addr_checks.sail` L40-41.
pub fn ext_control_check_addr(pc: BitVector<{
    64
}>) -> Ext_ControlAddr_Check<()> {
    Ext_ControlAddr_Check::Ext_ControlAddr_OK(virtaddr::Virtaddr(pc))
}

/// ext_control_check_pc
/// 
/// Generated from the Sail sources at `riscv_addr_checks.sail` L44-45.
pub fn ext_control_check_pc(pc: BitVector<{
    64
}>) -> Ext_ControlAddr_Check<()> {
    Ext_ControlAddr_Check::Ext_ControlAddr_OK(virtaddr::Virtaddr(pc))
}

pub type ext_data_addr_error = ();

/// ext_data_get_addr
/// 
/// Generated from the Sail sources at `riscv_addr_checks.sail` L57-60.
pub fn ext_data_get_addr(core_ctx: &mut Core, base: regidx, offset: BitVector<{
    64
}>, acc: AccessType<()>, width: i128) -> Ext_DataAddr_Check<()> {
    let addr = {
        let var_1 = rX_bits(core_ctx, base).wrapped_add(offset);
        virtaddr::Virtaddr(var_1)
    };
    Ext_DataAddr_Check::Ext_DataAddr_OK(addr)
}

pub type vreglenbits = BitVector<vlenmax>;

pub type vregtype = vreglenbits;

/// maskfunct3
/// 
/// Generated from the Sail sources at `riscv_vreg_type.sail` L108.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum maskfunct3 {
    VV_VMERGE,
    VI_VMERGE,
    VX_VMERGE
}

/// vregno
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L10.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum vregno {
    Vregno(i128)
}

/// vregidx_bits
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L14.
pub fn vregidx_bits(vregidx::Vregidx(b): vregidx) -> BitVector<5> {
    b
}

/// encdec_vreg_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vreg_backwards(arg_hashtag_: BitVector<5>) -> vregidx {
    match arg_hashtag_ {
        r => {vregidx::Vregidx(r)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vreg_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vreg_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        r => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

pub const zvreg: vregidx = vregidx::Vregidx(BitVector::<5>::new(0b00000));

/// dirty_v_context
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L94-99.
pub fn dirty_v_context(core_ctx: &mut Core, unit_arg: ()) {
    assert!(hartSupports(core_ctx, extension::Ext_V), "riscv_vext_regs.sail:95.28-95.29");
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<9, 11, 2>(extStatus_to_bits(ExtStatus::Dirty));
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<63, 64, 1>(BitVector::<1>::new(0b1))
}

/// _get_Vcsr_vxrm
/// 
/// Generated from the Sail sources.
pub fn _get_Vcsr_vxrm(v: Vcsr) -> BitVector<2> {
    v.bits.subrange::<1, 3, 2>()
}

/// _get_Vcsr_vxsat
/// 
/// Generated from the Sail sources.
pub fn _get_Vcsr_vxsat(v: Vcsr) -> BitVector<1> {
    v.bits.subrange::<0, 1, 1>()
}

/// ext_write_vcsr
/// 
/// Generated from the Sail sources at `riscv_vext_regs.sail` L233-237.
pub fn ext_write_vcsr(core_ctx: &mut Core, vxrm_val: BitVector<2>, vxsat_val: BitVector<1>) {
    core_ctx.vcsr.bits = core_ctx.vcsr.bits.set_subrange::<1, 3, 2>(vxrm_val);
    core_ctx.vcsr.bits = core_ctx.vcsr.bits.set_subrange::<0, 1, 1>(vxsat_val);
    dirty_v_context(core_ctx, ())
}

/// set_vstart
/// 
/// Generated from the Sail sources at `riscv_vext_control.sail` L15-20.
pub fn set_vstart(core_ctx: &mut Core, value: BitVector<16>) {
    dirty_v_context(core_ctx, ());
    core_ctx.vstart = value.subrange::<0, 3, 3>().zero_extend::<16>()
}

pub type ext_exception = ();

/// ext_check_xret_priv
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L14.
pub const fn ext_check_xret_priv(p: Privilege) -> bool {
    true
}

/// handle_trap_extension
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L18.
pub const fn handle_trap_extension(p: Privilege, pc: BitVector<{
    64
}>, u: Option<()>) {
    ()
}

/// prepare_trap_vector
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L21-31.
pub fn prepare_trap_vector(core_ctx: &mut Core, p: Privilege, cause: Mcause) -> BitVector<{
    64
}> {
    let tvec: Mtvec = match p {
        Privilege::Machine => {core_ctx.mtvec}
        Privilege::Supervisor => {core_ctx.stvec}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sys_exceptions.sail", 25, "Invalid privilege level")}
        _ => {panic!("Unreachable code")}
    };
    match tvec_addr(tvec, cause) {
        Some(epc) => {epc}
        None => {panic!("{}, l {}: {}", "riscv_sys_exceptions.sail", 29, "Invalid tvec mode")}
        _ => {panic!("Unreachable code")}
    }
}

/// get_xepc
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L41-46.
pub fn get_xepc(core_ctx: &mut Core, p: Privilege) -> BitVector<{
    64
}> {
    match p {
        Privilege::Machine => {{
            let var_1 = core_ctx.mepc;
            align_pc(core_ctx, var_1)
        }}
        Privilege::Supervisor => {{
            let var_2 = core_ctx.sepc;
            align_pc(core_ctx, var_2)
        }}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sys_exceptions.sail", 45, "Invalid privilege level")}
        _ => {panic!("Unreachable code")}
    }
}

/// set_xepc
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L49-57.
pub fn set_xepc(core_ctx: &mut Core, p: Privilege, value: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    let target = legalize_xepc(core_ctx, value);
    match p {
        Privilege::Machine => {core_ctx.mepc = target}
        Privilege::Supervisor => {core_ctx.sepc = target}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sys_exceptions.sail", 54, "Invalid privilege level")}
        _ => {panic!("Unreachable code")}
    };
    target
}

/// prepare_xret_target
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L60-61.
pub fn prepare_xret_target(core_ctx: &mut Core, p: Privilege) -> BitVector<{
    64
}> {
    get_xepc(core_ctx, p)
}

/// get_mtvec
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L65-66.
pub fn get_mtvec(core_ctx: &mut Core, unit_arg: ()) -> BitVector<{
    64
}> {
    core_ctx.mtvec.bits
}

/// get_stvec
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L68-69.
pub fn get_stvec(core_ctx: &mut Core, unit_arg: ()) -> BitVector<{
    64
}> {
    core_ctx.stvec.bits
}

/// set_mtvec
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L71-74.
pub fn set_mtvec(core_ctx: &mut Core, value: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    core_ctx.mtvec = {
        let var_1 = core_ctx.mtvec;
        legalize_tvec(var_1, value)
    };
    core_ctx.mtvec.bits
}

/// set_stvec
/// 
/// Generated from the Sail sources at `riscv_sys_exceptions.sail` L76-79.
pub fn set_stvec(core_ctx: &mut Core, value: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    core_ctx.stvec = {
        let var_1 = core_ctx.stvec;
        legalize_tvec(var_1, value)
    };
    core_ctx.stvec.bits
}

/// sync_exception
/// 
/// Generated from the Sail sources at `riscv_sync_exception.sail` L11-15.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct sync_exception {
    pub trap: ExceptionType,
    pub excinfo: Option<xlenbits>,
    pub ext: Option<ext_exception>,
}

/// Mk_HpmEvent
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_HpmEvent(v: BitVector<64>) -> HpmEvent {
    HpmEvent {
        bits: v
    }
}

/// _get_HpmEvent_MINH
/// 
/// Generated from the Sail sources.
pub fn _get_HpmEvent_MINH(v: HpmEvent) -> BitVector<1> {
    v.bits.subrange::<62, 63, 1>()
}

/// _update_HpmEvent_MINH
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_MINH(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 62, 62, x)
    }
}

/// _update_CountSmcntrpmf_MINH
/// 
/// Generated from the Sail sources.
pub fn _update_CountSmcntrpmf_MINH(v: CountSmcntrpmf, x: BitVector<1>) -> CountSmcntrpmf {
    CountSmcntrpmf {
        bits: update_subrange_bits(v.bits, 62, 62, x)
    }
}

/// _get_CountSmcntrpmf_MINH
/// 
/// Generated from the Sail sources.
pub fn _get_CountSmcntrpmf_MINH(v: CountSmcntrpmf) -> BitVector<1> {
    v.bits.subrange::<62, 63, 1>()
}

/// _get_HpmEvent_OF
/// 
/// Generated from the Sail sources.
pub fn _get_HpmEvent_OF(v: HpmEvent) -> BitVector<1> {
    v.bits.subrange::<63, 64, 1>()
}

/// _update_HpmEvent_OF
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_OF(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 63, 63, x)
    }
}

/// _get_HpmEvent_SINH
/// 
/// Generated from the Sail sources.
pub fn _get_HpmEvent_SINH(v: HpmEvent) -> BitVector<1> {
    v.bits.subrange::<61, 62, 1>()
}

/// _update_HpmEvent_SINH
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_SINH(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 61, 61, x)
    }
}

/// _update_CountSmcntrpmf_SINH
/// 
/// Generated from the Sail sources.
pub fn _update_CountSmcntrpmf_SINH(v: CountSmcntrpmf, x: BitVector<1>) -> CountSmcntrpmf {
    CountSmcntrpmf {
        bits: update_subrange_bits(v.bits, 61, 61, x)
    }
}

/// _get_CountSmcntrpmf_SINH
/// 
/// Generated from the Sail sources.
pub fn _get_CountSmcntrpmf_SINH(v: CountSmcntrpmf) -> BitVector<1> {
    v.bits.subrange::<61, 62, 1>()
}

/// _get_HpmEvent_UINH
/// 
/// Generated from the Sail sources.
pub fn _get_HpmEvent_UINH(v: HpmEvent) -> BitVector<1> {
    v.bits.subrange::<60, 61, 1>()
}

/// _update_HpmEvent_UINH
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_UINH(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 60, 60, x)
    }
}

/// _update_CountSmcntrpmf_UINH
/// 
/// Generated from the Sail sources.
pub fn _update_CountSmcntrpmf_UINH(v: CountSmcntrpmf, x: BitVector<1>) -> CountSmcntrpmf {
    CountSmcntrpmf {
        bits: update_subrange_bits(v.bits, 60, 60, x)
    }
}

/// _get_CountSmcntrpmf_UINH
/// 
/// Generated from the Sail sources.
pub fn _get_CountSmcntrpmf_UINH(v: CountSmcntrpmf) -> BitVector<1> {
    v.bits.subrange::<60, 61, 1>()
}

/// _update_HpmEvent_VSINH
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_VSINH(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 59, 59, x)
    }
}

/// _update_HpmEvent_VUINH
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_VUINH(v: HpmEvent, x: BitVector<1>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 58, 58, x)
    }
}

/// _get_HpmEvent_event
/// 
/// Generated from the Sail sources.
pub fn _get_HpmEvent_event(v: HpmEvent) -> BitVector<32> {
    v.bits.subrange::<0, 32, 32>()
}

/// _update_HpmEvent_event
/// 
/// Generated from the Sail sources.
pub fn _update_HpmEvent_event(v: HpmEvent, x: BitVector<32>) -> HpmEvent {
    HpmEvent {
        bits: update_subrange_bits(v.bits, 31, 0, x)
    }
}

pub type hpmidx = i128;

/// hpmidx_from_bits
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L189-193.
pub fn hpmidx_from_bits(b: BitVector<5>) -> i128 {
    let index = b.unsigned();
    assert!((index >= 3), "unreachable HPM index");
    index
}

/// legalize_hpmevent
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L195-205.
pub fn legalize_hpmevent(core_ctx: &mut Core, v: HpmEvent) -> HpmEvent {
    {
        let var_1 = {
            let var_2 = {
                let var_3 = {
                    let var_4 = {
                        let var_6 = {
                            let var_8 = {
                                let var_10 = if {currentlyEnabled(core_ctx, extension::Ext_Sscofpmf)} {
                                    _get_HpmEvent_OF(v)
                                } else {
                                    BitVector::<1>::new(0b0)
                                };
                                _update_HpmEvent_OF(Mk_HpmEvent(zeros::<64>(64)), var_10)
                            };
                            let var_9 = if {currentlyEnabled(core_ctx, extension::Ext_Sscofpmf)} {
                                _get_HpmEvent_MINH(v)
                            } else {
                                BitVector::<1>::new(0b0)
                            };
                            _update_HpmEvent_MINH(var_8, var_9)
                        };
                        let var_7 = if {(currentlyEnabled(core_ctx, extension::Ext_Sscofpmf) && currentlyEnabled(core_ctx, extension::Ext_S))} {
                            _get_HpmEvent_SINH(v)
                        } else {
                            BitVector::<1>::new(0b0)
                        };
                        _update_HpmEvent_SINH(var_6, var_7)
                    };
                    let var_5 = if {(currentlyEnabled(core_ctx, extension::Ext_Sscofpmf) && currentlyEnabled(core_ctx, extension::Ext_U))} {
                        _get_HpmEvent_UINH(v)
                    } else {
                        BitVector::<1>::new(0b0)
                    };
                    _update_HpmEvent_UINH(var_4, var_5)
                };
                _update_HpmEvent_VSINH(var_3, BitVector::<1>::new(0b0))
            };
            _update_HpmEvent_VUINH(var_2, BitVector::<1>::new(0b0))
        };
        _update_HpmEvent_event(var_1, _get_HpmEvent_event(v))
    }
}

/// read_mhpmcounter
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L207.
pub fn read_mhpmcounter(core_ctx: &mut Core, index: i128) -> BitVector<{
    64
}> {
    subrange_bits::<_, 64>(core_ctx.mhpmcounter[(index as usize)], 63, 0)
}

/// read_mhpmcounterh
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L208.
pub fn read_mhpmcounterh(core_ctx: &mut Core, index: i128) -> BitVector<32> {
    subrange_bits::<_, 32>(core_ctx.mhpmcounter[(index as usize)], 63, 32)
}

/// read_mhpmevent
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L209.
pub fn read_mhpmevent(core_ctx: &mut Core, index: i128) -> BitVector<{
    64
}> {
    core_ctx.mhpmevent[(index as usize)].bits.subrange::<0, 64, 64>()
}

/// write_mhpmcounter
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L212-213.
pub fn write_mhpmcounter(core_ctx: &mut Core, index: i128, value: BitVector<{
    64
}>) {
    if {(bitvector_access(sys_writable_hpm_counters(core_ctx, ()), index) == true)} {
        core_ctx.mhpmcounter[(index as usize)] = core_ctx.mhpmcounter[(index as usize)].set_subrange::<0, 64, 64>(value)
    } else {
        ()
    }
}

/// write_mhpmcounterh
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L215-216.
pub fn write_mhpmcounterh(core_ctx: &mut Core, index: i128, value: BitVector<32>) {
    if {(bitvector_access(sys_writable_hpm_counters(core_ctx, ()), index) == true)} {
        core_ctx.mhpmcounter[(index as usize)] = core_ctx.mhpmcounter[(index as usize)].set_subrange::<32, 64, 32>(value)
    } else {
        ()
    }
}

/// write_mhpmevent
/// 
/// Generated from the Sail sources at `riscv_zihpm.sail` L218-224.
pub fn write_mhpmevent(core_ctx: &mut Core, index: i128, value: BitVector<{
    64
}>) {
    if {(bitvector_access(sys_writable_hpm_counters(core_ctx, ()), index) == true)} {
        core_ctx.mhpmevent[(index as usize)] = legalize_hpmevent(core_ctx, Mk_HpmEvent(value))
    } else {
        ()
    }
}

/// read_mhpmeventh
/// 
/// Generated from the Sail sources at `riscv_sscofpmf.sail` L44.
pub fn read_mhpmeventh(core_ctx: &mut Core, index: i128) -> BitVector<32> {
    core_ctx.mhpmevent[(index as usize)].bits.subrange::<32, 64, 32>()
}

/// write_mhpmeventh
/// 
/// Generated from the Sail sources at `riscv_sscofpmf.sail` L46-48.
pub fn write_mhpmeventh(core_ctx: &mut Core, index: i128, value: BitVector<32>) {
    if {(bitvector_access(sys_writable_hpm_counters(core_ctx, ()), index) == true)} {
        core_ctx.mhpmevent[(index as usize)] = legalize_hpmevent(core_ctx, Mk_HpmEvent(bitvector_concat::<32, 32, 64>(value, core_ctx.mhpmevent[(index as usize)].bits.subrange::<0, 32, 32>())))
    } else {
        ()
    }
}

/// get_scountovf
/// 
/// Generated from the Sail sources at `riscv_sscofpmf.sail` L60-76.
pub fn get_scountovf(core_ctx: &mut Core, _priv_: Privilege) -> BitVector<32> {
    let overflow = bitvector_concat::<1, 31, 32>(_get_HpmEvent_OF(core_ctx.mhpmevent[(31 as usize)]), bitvector_concat::<1, 30, 31>(_get_HpmEvent_OF(core_ctx.mhpmevent[(30 as usize)]), bitvector_concat::<1, 29, 30>(_get_HpmEvent_OF(core_ctx.mhpmevent[(29 as usize)]), bitvector_concat::<1, 28, 29>(_get_HpmEvent_OF(core_ctx.mhpmevent[(28 as usize)]), bitvector_concat::<1, 27, 28>(_get_HpmEvent_OF(core_ctx.mhpmevent[(27 as usize)]), bitvector_concat::<1, 26, 27>(_get_HpmEvent_OF(core_ctx.mhpmevent[(26 as usize)]), bitvector_concat::<1, 25, 26>(_get_HpmEvent_OF(core_ctx.mhpmevent[(25 as usize)]), bitvector_concat::<1, 24, 25>(_get_HpmEvent_OF(core_ctx.mhpmevent[(24 as usize)]), bitvector_concat::<1, 23, 24>(_get_HpmEvent_OF(core_ctx.mhpmevent[(23 as usize)]), bitvector_concat::<1, 22, 23>(_get_HpmEvent_OF(core_ctx.mhpmevent[(22 as usize)]), bitvector_concat::<1, 21, 22>(_get_HpmEvent_OF(core_ctx.mhpmevent[(21 as usize)]), bitvector_concat::<1, 20, 21>(_get_HpmEvent_OF(core_ctx.mhpmevent[(20 as usize)]), bitvector_concat::<1, 19, 20>(_get_HpmEvent_OF(core_ctx.mhpmevent[(19 as usize)]), bitvector_concat::<1, 18, 19>(_get_HpmEvent_OF(core_ctx.mhpmevent[(18 as usize)]), bitvector_concat::<1, 17, 18>(_get_HpmEvent_OF(core_ctx.mhpmevent[(17 as usize)]), bitvector_concat::<1, 16, 17>(_get_HpmEvent_OF(core_ctx.mhpmevent[(16 as usize)]), bitvector_concat::<1, 15, 16>(_get_HpmEvent_OF(core_ctx.mhpmevent[(15 as usize)]), bitvector_concat::<1, 14, 15>(_get_HpmEvent_OF(core_ctx.mhpmevent[(14 as usize)]), bitvector_concat::<1, 13, 14>(_get_HpmEvent_OF(core_ctx.mhpmevent[(13 as usize)]), bitvector_concat::<1, 12, 13>(_get_HpmEvent_OF(core_ctx.mhpmevent[(12 as usize)]), bitvector_concat::<1, 11, 12>(_get_HpmEvent_OF(core_ctx.mhpmevent[(11 as usize)]), bitvector_concat::<1, 10, 11>(_get_HpmEvent_OF(core_ctx.mhpmevent[(10 as usize)]), bitvector_concat::<1, 9, 10>(_get_HpmEvent_OF(core_ctx.mhpmevent[(9 as usize)]), bitvector_concat::<1, 8, 9>(_get_HpmEvent_OF(core_ctx.mhpmevent[(8 as usize)]), bitvector_concat::<1, 7, 8>(_get_HpmEvent_OF(core_ctx.mhpmevent[(7 as usize)]), bitvector_concat::<1, 6, 7>(_get_HpmEvent_OF(core_ctx.mhpmevent[(6 as usize)]), bitvector_concat::<1, 5, 6>(_get_HpmEvent_OF(core_ctx.mhpmevent[(5 as usize)]), bitvector_concat::<1, 4, 5>(_get_HpmEvent_OF(core_ctx.mhpmevent[(4 as usize)]), bitvector_concat::<1, 3, 4>(_get_HpmEvent_OF(core_ctx.mhpmevent[(3 as usize)]), BitVector::<3>::new(0b000))))))))))))))))))))))))))))));
    match _priv_ {
        Privilege::Machine => {overflow}
        Privilege::Supervisor => {(overflow & core_ctx.mcounteren.bits)}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sscofpmf.sail", 74, "scountovf not readable from User mode")}
        _ => {panic!("Unreachable code")}
    }
}

/// seed_opst
/// 
/// Generated from the Sail sources at `riscv_zkr_control.sail` L13-18.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum seed_opst {
    BIST,
    ES16,
    WAIT,
    DEAD
}

/// opst_code_forwards
/// 
/// Generated from the Sail sources.
pub fn opst_code_forwards(arg_hashtag_: seed_opst) -> BitVector<2> {
    match arg_hashtag_ {
        seed_opst::BIST => {BitVector::<2>::new(0b00)}
        seed_opst::WAIT => {BitVector::<2>::new(0b01)}
        seed_opst::ES16 => {BitVector::<2>::new(0b10)}
        seed_opst::DEAD => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// read_seed_csr
/// 
/// Generated from the Sail sources at `riscv_zkr_control.sail` L33-38.
pub fn read_seed_csr(unit_arg: ()) -> BitVector<{
    64
}> {
    let reserved_bits: BitVector<6> = BitVector::<6>::new(0b000000);
    let custom_bits: BitVector<8> = BitVector::<8>::new(0b00000000);
    let seed: BitVector<16> = get_16_random_bits(());
    bitvector_concat::<2, 30, 32>(opst_code_forwards(seed_opst::ES16), bitvector_concat::<6, 24, 30>(reserved_bits, bitvector_concat::<8, 16, 24>(custom_bits, seed))).zero_extend::<64>()
}

/// write_seed_csr
/// 
/// Generated from the Sail sources at `riscv_zkr_control.sail` L41.
pub fn write_seed_csr(unit_arg: ()) -> BitVector<{
    64
}> {
    zeros::<64>(64)
}

pub type bits_rm = BitVector<3>;

pub type bits_fflags = BitVector<5>;

pub type bits_H = BitVector<16>;

pub type bits_S = BitVector<32>;

pub type bits_D = BitVector<64>;

pub type bits_W = BitVector<32>;

pub type bits_WU = BitVector<32>;

pub type bits_L = BitVector<64>;

pub type bits_LU = BitVector<64>;

/// fregno
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L56.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum fregno {
    Fregno(i128)
}

/// fregidx_bits
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L60.
pub fn fregidx_bits(fregidx::Fregidx(r): fregidx) -> BitVector<5> {
    r
}

/// cregidx_to_fregidx
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L62.
pub fn cregidx_to_fregidx(cregidx::Cregidx(b): cregidx) -> fregidx {
    fregidx::Fregidx(bitvector_concat::<2, 3, 5>(BitVector::<2>::new(0b01), b))
}

/// encdec_freg_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_freg_backwards(arg_hashtag_: BitVector<5>) -> fregidx {
    match arg_hashtag_ {
        r => {fregidx::Fregidx(r)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_freg_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_freg_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        r => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// dirty_fd_context
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L109-114.
pub fn dirty_fd_context(core_ctx: &mut Core, unit_arg: ()) {
    assert!(hartSupports(core_ctx, extension::Ext_F), "riscv_fdext_regs.sail:110.28-110.29");
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<13, 15, 2>(extStatus_to_bits(ExtStatus::Dirty));
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<63, 64, 1>(BitVector::<1>::new(0b1))
}

/// dirty_fd_context_if_present
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L116-119.
pub fn dirty_fd_context_if_present(core_ctx: &mut Core, unit_arg: ()) {
    assert!({
        let var_1 = hartSupports(core_ctx, extension::Ext_F);
        let var_2 = hartSupports(core_ctx, extension::Ext_Zfinx);
        neq_bool(var_1, var_2)
    }, "riscv_fdext_regs.sail:117.55-117.56");
    if {hartSupports(core_ctx, extension::Ext_F)} {
        dirty_fd_context(core_ctx, ())
    } else {
        ()
    }
}

/// _get_Fcsr_FFLAGS
/// 
/// Generated from the Sail sources.
pub fn _get_Fcsr_FFLAGS(v: Fcsr) -> BitVector<5> {
    v.bits.subrange::<0, 5, 5>()
}

/// _get_Fcsr_FRM
/// 
/// Generated from the Sail sources.
pub fn _get_Fcsr_FRM(v: Fcsr) -> BitVector<3> {
    v.bits.subrange::<5, 8, 3>()
}

/// write_fcsr
/// 
/// Generated from the Sail sources at `riscv_fdext_regs.sail` L392-396.
pub fn write_fcsr(core_ctx: &mut Core, frm: BitVector<3>, fflags: BitVector<5>) {
    core_ctx.fcsr.bits = core_ctx.fcsr.bits.set_subrange::<5, 8, 3>(frm);
    core_ctx.fcsr.bits = core_ctx.fcsr.bits.set_subrange::<0, 5, 5>(fflags);
    dirty_fd_context_if_present(core_ctx, ())
}

/// Mk_CountSmcntrpmf
/// 
/// Generated from the Sail sources at `` L1.
pub fn Mk_CountSmcntrpmf(v: BitVector<64>) -> CountSmcntrpmf {
    CountSmcntrpmf {
        bits: v
    }
}

/// legalize_smcntrpmf
/// 
/// Generated from the Sail sources at `riscv_smcntrpmf.sail` L11-21.
pub fn legalize_smcntrpmf(core_ctx: &mut Core, c: CountSmcntrpmf, value: BitVector<64>) -> CountSmcntrpmf {
    let v = Mk_CountSmcntrpmf(value);
    {
        let var_1 = {
            let var_3 = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
                _get_CountSmcntrpmf_SINH(v)
            } else {
                BitVector::<1>::new(0b0)
            };
            _update_CountSmcntrpmf_SINH(_update_CountSmcntrpmf_MINH(c, _get_CountSmcntrpmf_MINH(v)), var_3)
        };
        let var_2 = if {currentlyEnabled(core_ctx, extension::Ext_U)} {
            _get_CountSmcntrpmf_UINH(v)
        } else {
            BitVector::<1>::new(0b0)
        };
        _update_CountSmcntrpmf_UINH(var_1, var_2)
    }
}

/// csrAccess
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L13.
pub fn csrAccess(csr: BitVector<12>) -> BitVector<2> {
    csr.subrange::<10, 12, 2>()
}

/// csrPriv
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L14.
pub fn csrPriv(csr: BitVector<12>) -> BitVector<2> {
    csr.subrange::<8, 10, 2>()
}

/// check_CSR_priv
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L17-18.
pub fn check_CSR_priv(csr: BitVector<12>, p: Privilege) -> bool {
    _operator_biggerequal_u_(privLevel_to_bits(p), csrPriv(csr))
}

/// check_CSR_access
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L21-22.
pub fn check_CSR_access(csr: BitVector<12>, isWrite: bool) -> bool {
    !((isWrite && (csrAccess(csr) == BitVector::<2>::new(0b11))))
}

/// check_TVM_SATP
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L24-25.
pub fn check_TVM_SATP(core_ctx: &mut Core, csr: BitVector<12>, p: Privilege) -> bool {
    !(((csr == BitVector::<12>::new(0b000110000000)) && ((p == Privilege::Supervisor) && ({
        let var_1 = core_ctx.mstatus;
        _get_Mstatus_TVM(var_1)
    } == BitVector::<1>::new(0b1)))))
}

/// feature_enabled_for_priv
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L29-33.
pub fn feature_enabled_for_priv(core_ctx: &mut Core, p: Privilege, machine_enable_bit: bool, supervisor_enable_bit: bool) -> bool {
    match p {
        Privilege::Machine => {true}
        Privilege::Supervisor => {(machine_enable_bit == true)}
        Privilege::User => {((machine_enable_bit == true) && (!(currentlyEnabled(core_ctx, extension::Ext_S)) || (supervisor_enable_bit == true)))}
        _ => {panic!("Unreachable code")}
    }
}

/// check_Counteren
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L36-43.
pub fn check_Counteren(core_ctx: &mut Core, csr: BitVector<12>, p: Privilege) -> bool {
    if {(_operator_smaller_u_(csr, BitVector::<12>::new(0b110000000000)) || _operator_smaller_u_(BitVector::<12>::new(0b110000011111), csr))} {
        return true;
    } else {
        ()
    };
    let index = csr.subrange::<0, 5, 5>().unsigned();
    {
        let var_1 = bitvector_access(core_ctx.mcounteren.bits, index);
        let var_2 = bitvector_access(core_ctx.scounteren.bits, index);
        feature_enabled_for_priv(core_ctx, p, var_1, var_2)
    }
}

/// check_Stimecmp
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L46-51.
pub fn check_Stimecmp(core_ctx: &mut Core, csr: BitVector<12>, p: Privilege) -> bool {
    if {((csr != BitVector::<12>::new(0b000101001101)) && (csr != BitVector::<12>::new(0b000101011101)))} {
        return true;
    } else {
        ()
    };
    ((p == Privilege::Machine) || ((p == Privilege::Supervisor) && (({
        let var_2 = core_ctx.mcounteren;
        _get_Counteren_TM(var_2)
    } == BitVector::<1>::new(0b1)) && ({
        let var_1 = core_ctx.menvcfg;
        _get_MEnvcfg_STCE(var_1)
    } == BitVector::<1>::new(0b1)))))
}

/// check_seed_CSR
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L56-69.
pub fn check_seed_CSR(csr: BitVector<12>, p: Privilege, isWrite: bool) -> bool {
    if {!((csr == BitVector::<12>::new(0b000000010101)))} {
        true
    } else if {!(isWrite)} {
        false
    } else {
        match p {
            Privilege::Machine => {true}
            Privilege::Supervisor => {false}
            Privilege::User => {false}
            _ => {panic!("Unreachable code")}
        }
    }
}

/// is_CSR_defined
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L133.
pub fn is_CSR_defined(core_ctx: &mut Core, merge_hashtag_var: BitVector<12>) -> bool {
    match merge_hashtag_var {
        b__0 if {(b__0 == BitVector::<12>::new(0b001100000001))} => {true}
        b__1 if {(b__1 == BitVector::<12>::new(0b001100000000))} => {true}
        b__2 if {(b__2 == BitVector::<12>::new(0b001100010000))} => {false}
        b__3 if {(b__3 == BitVector::<12>::new(0b001100001010))} => {currentlyEnabled(core_ctx, extension::Ext_U)}
        b__4 if {(b__4 == BitVector::<12>::new(0b001100011010))} => {false}
        b__5 if {(b__5 == BitVector::<12>::new(0b000100001010))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__6 if {(b__6 == BitVector::<12>::new(0b001100000100))} => {true}
        b__7 if {(b__7 == BitVector::<12>::new(0b001101000100))} => {true}
        b__8 if {(b__8 == BitVector::<12>::new(0b001100000010))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__9 if {(b__9 == BitVector::<12>::new(0b001100010010))} => {false}
        b__10 if {(b__10 == BitVector::<12>::new(0b001100000011))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__11 if {(b__11 == BitVector::<12>::new(0b001101000010))} => {true}
        b__12 if {(b__12 == BitVector::<12>::new(0b001101000011))} => {true}
        b__13 if {(b__13 == BitVector::<12>::new(0b001101000000))} => {true}
        b__14 if {(b__14 == BitVector::<12>::new(0b000100000110))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__15 if {(b__15 == BitVector::<12>::new(0b001100000110))} => {currentlyEnabled(core_ctx, extension::Ext_U)}
        b__16 if {(b__16 == BitVector::<12>::new(0b001100100000))} => {true}
        b__17 if {(b__17 == BitVector::<12>::new(0b111100010001))} => {true}
        b__18 if {(b__18 == BitVector::<12>::new(0b111100010010))} => {true}
        b__19 if {(b__19 == BitVector::<12>::new(0b111100010011))} => {true}
        b__20 if {(b__20 == BitVector::<12>::new(0b111100010100))} => {true}
        b__21 if {(b__21 == BitVector::<12>::new(0b111100010101))} => {true}
        b__22 if {(b__22 == BitVector::<12>::new(0b000100000000))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__23 if {(b__23 == BitVector::<12>::new(0b000101000100))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__24 if {(b__24 == BitVector::<12>::new(0b000100000100))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__25 if {(b__25 == BitVector::<12>::new(0b000101000000))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__26 if {(b__26 == BitVector::<12>::new(0b000101000010))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__27 if {(b__27 == BitVector::<12>::new(0b000101000011))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__28 if {(b__28 == BitVector::<12>::new(0b011110100000))} => {true}
        v__3804 if {(v__3804.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111010))} => {let idx: BitVector<4> = v__3804.subrange::<0, 4, 4>();
        ((sys_pmp_count(core_ctx, ()) > (4 * idx.unsigned())) && (bitvector_access(idx, 0) == false))}
        v__3806 if {(v__3806.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111011))} => {let idx: BitVector<4> = v__3806.subrange::<0, 4, 4>();
        (sys_pmp_count(core_ctx, ()) > bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b00), idx).unsigned())}
        v__3808 if {(v__3808.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111100))} => {let idx: BitVector<4> = v__3808.subrange::<0, 4, 4>();
        (sys_pmp_count(core_ctx, ()) > bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b01), idx).unsigned())}
        v__3810 if {(v__3810.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111101))} => {let idx: BitVector<4> = v__3810.subrange::<0, 4, 4>();
        (sys_pmp_count(core_ctx, ()) > bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b10), idx).unsigned())}
        v__3812 if {(v__3812.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111110))} => {let idx: BitVector<4> = v__3812.subrange::<0, 4, 4>();
        (sys_pmp_count(core_ctx, ()) > bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b11), idx).unsigned())}
        b__29 if {(b__29 == BitVector::<12>::new(0b000000001000))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__30 if {(b__30 == BitVector::<12>::new(0b000000001001))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__31 if {(b__31 == BitVector::<12>::new(0b000000001010))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__32 if {(b__32 == BitVector::<12>::new(0b000000001111))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__33 if {(b__33 == BitVector::<12>::new(0b110000100000))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__34 if {(b__34 == BitVector::<12>::new(0b110000100001))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__35 if {(b__35 == BitVector::<12>::new(0b110000100010))} => {currentlyEnabled(core_ctx, extension::Ext_V)}
        b__36 if {(b__36 == BitVector::<12>::new(0b000100000101))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__37 if {(b__37 == BitVector::<12>::new(0b000101000001))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        b__38 if {(b__38 == BitVector::<12>::new(0b001100000101))} => {true}
        b__39 if {(b__39 == BitVector::<12>::new(0b001101000001))} => {true}
        v__3814 if {let index_var_1: BitVector<5> = v__3814.subrange::<0, 5, 5>();
        ((v__3814.subrange::<5, 12, 7>() == BitVector::<7>::new(0b0011001)) && ((index_var_1.unsigned() >= 3) as bool))} => {currentlyEnabled(core_ctx, extension::Ext_Zihpm)}
        v__3816 if {let index_var_2: BitVector<5> = v__3816.subrange::<0, 5, 5>();
        ((v__3816.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1011000)) && ((index_var_2.unsigned() >= 3) as bool))} => {currentlyEnabled(core_ctx, extension::Ext_Zihpm)}
        v__3818 if {let index_var_3: BitVector<5> = v__3818.subrange::<0, 5, 5>();
        ((v__3818.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1011100)) && ((index_var_3.unsigned() >= 3) as bool))} => {false}
        v__3820 if {let index_var_4: BitVector<5> = v__3820.subrange::<0, 5, 5>();
        ((v__3820.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1100000)) && ((index_var_4.unsigned() >= 3) as bool))} => {(currentlyEnabled(core_ctx, extension::Ext_Zihpm) && currentlyEnabled(core_ctx, extension::Ext_U))}
        v__3822 if {let index_var_5: BitVector<5> = v__3822.subrange::<0, 5, 5>();
        ((v__3822.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1100100)) && ((index_var_5.unsigned() >= 3) as bool))} => {false}
        v__3824 if {let index_var_6: BitVector<5> = v__3824.subrange::<0, 5, 5>();
        ((v__3824.subrange::<5, 12, 7>() == BitVector::<7>::new(0b0111001)) && ((index_var_6.unsigned() >= 3) as bool))} => {false}
        b__40 if {(b__40 == BitVector::<12>::new(0b110110100000))} => {(currentlyEnabled(core_ctx, extension::Ext_Sscofpmf) && currentlyEnabled(core_ctx, extension::Ext_S))}
        b__41 if {(b__41 == BitVector::<12>::new(0b000000010101))} => {currentlyEnabled(core_ctx, extension::Ext_Zkr)}
        b__42 if {(b__42 == BitVector::<12>::new(0b110000000000))} => {currentlyEnabled(core_ctx, extension::Ext_Zicntr)}
        b__43 if {(b__43 == BitVector::<12>::new(0b110000000001))} => {currentlyEnabled(core_ctx, extension::Ext_Zicntr)}
        b__44 if {(b__44 == BitVector::<12>::new(0b110000000010))} => {currentlyEnabled(core_ctx, extension::Ext_Zicntr)}
        b__45 if {(b__45 == BitVector::<12>::new(0b110010000000))} => {false}
        b__46 if {(b__46 == BitVector::<12>::new(0b110010000001))} => {false}
        b__47 if {(b__47 == BitVector::<12>::new(0b110010000010))} => {false}
        b__48 if {(b__48 == BitVector::<12>::new(0b101100000000))} => {currentlyEnabled(core_ctx, extension::Ext_Zicntr)}
        b__49 if {(b__49 == BitVector::<12>::new(0b101100000010))} => {currentlyEnabled(core_ctx, extension::Ext_Zicntr)}
        b__50 if {(b__50 == BitVector::<12>::new(0b101110000000))} => {false}
        b__51 if {(b__51 == BitVector::<12>::new(0b101110000010))} => {false}
        b__52 if {(b__52 == BitVector::<12>::new(0b000000000001))} => {(currentlyEnabled(core_ctx, extension::Ext_F) || currentlyEnabled(core_ctx, extension::Ext_Zfinx))}
        b__53 if {(b__53 == BitVector::<12>::new(0b000000000010))} => {(currentlyEnabled(core_ctx, extension::Ext_F) || currentlyEnabled(core_ctx, extension::Ext_Zfinx))}
        b__54 if {(b__54 == BitVector::<12>::new(0b000000000011))} => {(currentlyEnabled(core_ctx, extension::Ext_F) || currentlyEnabled(core_ctx, extension::Ext_Zfinx))}
        b__55 if {(b__55 == BitVector::<12>::new(0b001100100001))} => {currentlyEnabled(core_ctx, extension::Ext_Smcntrpmf)}
        b__56 if {(b__56 == BitVector::<12>::new(0b011100100001))} => {false}
        b__57 if {(b__57 == BitVector::<12>::new(0b001100100010))} => {currentlyEnabled(core_ctx, extension::Ext_Smcntrpmf)}
        b__58 if {(b__58 == BitVector::<12>::new(0b011100100010))} => {false}
        b__59 if {(b__59 == BitVector::<12>::new(0b000101001101))} => {(currentlyEnabled(core_ctx, extension::Ext_S) && currentlyEnabled(core_ctx, extension::Ext_Sstc))}
        b__60 if {(b__60 == BitVector::<12>::new(0b000101011101))} => {false}
        b__61 if {(b__61 == BitVector::<12>::new(0b000110000000))} => {currentlyEnabled(core_ctx, extension::Ext_S)}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// check_CSR
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L71-81.
pub fn check_CSR(core_ctx: &mut Core, csr: BitVector<12>, p: Privilege, isWrite: bool) -> bool {
    (is_CSR_defined(core_ctx, csr) && (check_CSR_priv(csr, p) && (check_CSR_access(csr, isWrite) && (check_TVM_SATP(core_ctx, csr, p) && (check_Counteren(core_ctx, csr, p) && (check_Stimecmp(core_ctx, csr, p) && check_seed_CSR(csr, p, isWrite)))))))
}

/// exception_delegatee
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L104-111.
pub fn exception_delegatee(core_ctx: &mut Core, e: ExceptionType, p: Privilege) -> Privilege {
    let idx = num_of_ExceptionType(e);
    let _super_ = {
        let var_1 = bitvector_access(core_ctx.medeleg.bits, idx);
        bit_to_bool(var_1)
    };
    let deleg = if {(currentlyEnabled(core_ctx, extension::Ext_S) && _super_)} {
        Privilege::Supervisor
    } else {
        Privilege::Machine
    };
    if {_operator_smaller_u_(privLevel_to_bits(deleg), privLevel_to_bits(p))} {
        p
    } else {
        deleg
    }
}

/// findPendingInterrupt
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L116-125.
pub fn findPendingInterrupt(ip: BitVector<{
    64
}>) -> Option<InterruptType> {
    let ip = Mk_Minterrupts(ip);
    if {(_get_Minterrupts_MEI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_M_External)
    } else if {(_get_Minterrupts_MSI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_M_Software)
    } else if {(_get_Minterrupts_MTI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_M_Timer)
    } else if {(_get_Minterrupts_SEI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_S_External)
    } else if {(_get_Minterrupts_SSI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_S_Software)
    } else if {(_get_Minterrupts_STI(ip) == BitVector::<1>::new(0b1))} {
        Some(InterruptType::I_S_Timer)
    } else {
        None
    }
}

/// getPendingSet
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L135-148.
pub fn getPendingSet(core_ctx: &mut Core, _priv_: Privilege) -> Option<(BitVector<{
    64
}>, Privilege)> {
    assert!((currentlyEnabled(core_ctx, extension::Ext_S) || (core_ctx.mideleg.bits == zeros::<64>(64))), "riscv_sys_control.sail:137.58-137.59");
    let pending_m = (core_ctx.mip.bits & (core_ctx.mie.bits & !(core_ctx.mideleg.bits)));
    let pending_s = (core_ctx.mip.bits & (core_ctx.mie.bits & core_ctx.mideleg.bits));
    let mIE = (((_priv_ == Privilege::Machine) && ({
        let var_2 = core_ctx.mstatus;
        _get_Mstatus_MIE(var_2)
    } == BitVector::<1>::new(0b1))) || ((_priv_ == Privilege::Supervisor) || (_priv_ == Privilege::User)));
    let sIE = (((_priv_ == Privilege::Supervisor) && ({
        let var_1 = core_ctx.mstatus;
        _get_Mstatus_SIE(var_1)
    } == BitVector::<1>::new(0b1))) || (_priv_ == Privilege::User));
    if {(mIE && (pending_m != zeros::<64>(64)))} {
        Some((pending_m, Privilege::Machine))
    } else if {(sIE && (pending_s != zeros::<64>(64)))} {
        Some((pending_s, Privilege::Supervisor))
    } else {
        None
    }
}

/// dispatchInterrupt
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L177-185.
pub fn dispatchInterrupt(core_ctx: &mut Core, _priv_: Privilege) -> Option<(InterruptType, Privilege)> {
    match getPendingSet(core_ctx, _priv_) {
        None => {None}
        Some((ip, p)) => {match findPendingInterrupt(ip) {
            None => {None}
            Some(i) => {Some((i, p))}
            _ => {panic!("Unreachable code")}
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// ctl_result
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L189-193.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ctl_result {
    CTL_TRAP(sync_exception),
    CTL_SRET(()),
    CTL_MRET(())
}

/// tval
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L197-202.
pub fn tval(excinfo: Option<BitVector<{
    64
}>>) -> BitVector<{
    64
}> {
    match excinfo {
        Some(e) => {e}
        None => {zeros::<64>(64)}
        _ => {panic!("Unreachable code")}
    }
}

/// track_trap
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L204-219.
pub fn track_trap(core_ctx: &mut Core, p: Privilege) {
    match p {
        Privilege::Machine => {{
            
        }}
        Privilege::Supervisor => {{
            
        }}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sys_control.sail", 217, "Invalid privilege level")}
        _ => {panic!("Unreachable code")}
    }
}

/// trap_handler
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L222-275.
pub fn trap_handler(core_ctx: &mut Core, del_priv: Privilege, intr: bool, c: BitVector<8>, pc: BitVector<{
    64
}>, info: Option<BitVector<{
    64
}>>, ext: Option<()>) -> BitVector<{
    64
}> {
    match del_priv {
        Privilege::Machine => {{
            core_ctx.mcause.bits = core_ctx.mcause.bits.set_subrange::<63, 64, 1>(bool_to_bits(intr));
            core_ctx.mcause.bits = core_ctx.mcause.bits.set_subrange::<0, 63, 63>(c.zero_extend::<63>());
            core_ctx.mstatus.bits = {
                let var_1 = {
                    let var_2 = core_ctx.mstatus;
                    _get_Mstatus_MIE(var_2)
                };
                core_ctx.mstatus.bits.set_subrange::<7, 8, 1>(var_1)
            };
            core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<3, 4, 1>(BitVector::<1>::new(0b0));
            core_ctx.mstatus.bits = {
                let var_3 = {
                    let var_4 = core_ctx.cur_privilege;
                    privLevel_to_bits(var_4)
                };
                core_ctx.mstatus.bits.set_subrange::<11, 13, 2>(var_3)
            };
            core_ctx.mtval = tval(info);
            core_ctx.mepc = pc;
            core_ctx.cur_privilege = del_priv;
            track_trap(core_ctx, del_priv);
            {
                let var_5 = core_ctx.mcause;
                prepare_trap_vector(core_ctx, del_priv, var_5)
            }
        }}
        Privilege::Supervisor => {{
            assert!(currentlyEnabled(core_ctx, extension::Ext_S), "no supervisor mode present for delegation");
            core_ctx.scause.bits = core_ctx.scause.bits.set_subrange::<63, 64, 1>(bool_to_bits(intr));
            core_ctx.scause.bits = core_ctx.scause.bits.set_subrange::<0, 63, 63>(c.zero_extend::<63>());
            core_ctx.mstatus.bits = {
                let var_6 = {
                    let var_7 = core_ctx.mstatus;
                    _get_Mstatus_SIE(var_7)
                };
                core_ctx.mstatus.bits.set_subrange::<5, 6, 1>(var_6)
            };
            core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<1, 2, 1>(BitVector::<1>::new(0b0));
            core_ctx.mstatus.bits = {
                let var_8 = match core_ctx.cur_privilege {
                    Privilege::User => {BitVector::<1>::new(0b0)}
                    Privilege::Supervisor => {BitVector::<1>::new(0b1)}
                    Privilege::Machine => {panic!("{}, l {}: {}", "riscv_sys_control.sail", 260, "invalid privilege for s-mode trap")}
                    _ => {panic!("Unreachable code")}
                };
                core_ctx.mstatus.bits.set_subrange::<8, 9, 1>(var_8)
            };
            core_ctx.stval = tval(info);
            core_ctx.sepc = pc;
            core_ctx.cur_privilege = del_priv;
            track_trap(core_ctx, del_priv);
            {
                let var_9 = core_ctx.scause;
                prepare_trap_vector(core_ctx, del_priv, var_9)
            }
        }}
        Privilege::User => {panic!("{}, l {}: {}", "riscv_sys_control.sail", 273, "Invalid privilege level")}
        _ => {panic!("Unreachable code")}
    }
}

/// exception_handler
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L277-321.
pub fn exception_handler(core_ctx: &mut Core, cur_priv: Privilege, ctl: ctl_result, pc: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    match (cur_priv, ctl) {
        (_, ctl_result::CTL_TRAP(e)) => {{
            let del_priv = exception_delegatee(core_ctx, e.trap, cur_priv);
            trap_handler(core_ctx, del_priv, false, exceptionType_to_bits(e.trap), pc, e.excinfo, e.ext)
        }}
        (_, ctl_result::CTL_MRET(())) => {{
            let prev_priv = core_ctx.cur_privilege;
            core_ctx.mstatus.bits = {
                let var_1 = {
                    let var_2 = core_ctx.mstatus;
                    _get_Mstatus_MPIE(var_2)
                };
                core_ctx.mstatus.bits.set_subrange::<3, 4, 1>(var_1)
            };
            core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<7, 8, 1>(BitVector::<1>::new(0b1));
            core_ctx.cur_privilege = {
                let var_3 = {
                    let var_4 = core_ctx.mstatus;
                    _get_Mstatus_MPP(var_4)
                };
                privLevel_of_bits(var_3)
            };
            core_ctx.mstatus.bits = {
                let var_5 = {
                    let var_6 = if {currentlyEnabled(core_ctx, extension::Ext_U)} {
                        Privilege::User
                    } else {
                        Privilege::Machine
                    };
                    privLevel_to_bits(var_6)
                };
                core_ctx.mstatus.bits.set_subrange::<11, 13, 2>(var_5)
            };
            if {(core_ctx.cur_privilege != Privilege::Machine)} {
                core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<17, 18, 1>(BitVector::<1>::new(0b0))
            } else {
                ()
            };
            prepare_xret_target(core_ctx, Privilege::Machine)
        }}
        (_, ctl_result::CTL_SRET(())) => {{
            let prev_priv = core_ctx.cur_privilege;
            core_ctx.mstatus.bits = {
                let var_7 = {
                    let var_8 = core_ctx.mstatus;
                    _get_Mstatus_SPIE(var_8)
                };
                core_ctx.mstatus.bits.set_subrange::<1, 2, 1>(var_7)
            };
            core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<5, 6, 1>(BitVector::<1>::new(0b1));
            core_ctx.cur_privilege = if {({
                let var_9 = core_ctx.mstatus;
                _get_Mstatus_SPP(var_9)
            } == BitVector::<1>::new(0b1))} {
                Privilege::Supervisor
            } else {
                Privilege::User
            };
            core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<8, 9, 1>(BitVector::<1>::new(0b0));
            if {(core_ctx.cur_privilege != Privilege::Machine)} {
                core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<17, 18, 1>(BitVector::<1>::new(0b0))
            } else {
                ()
            };
            prepare_xret_target(core_ctx, Privilege::Supervisor)
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// handle_interrupt
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L337-338.
pub fn handle_interrupt(core_ctx: &mut Core, i: InterruptType, del_priv: Privilege) {
    let var_1 = {
        let var_2 = core_ctx.PC;
        trap_handler(core_ctx, del_priv, true, interruptType_to_bits(i), var_2, None, None)
    };
    set_next_pc(core_ctx, var_1)
}

/// reset_misa
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L341-360.
pub fn reset_misa(core_ctx: &mut Core, unit_arg: ()) {
    core_ctx.misa.bits = {
        let var_1 = {
            let var_2 = hartSupports(core_ctx, extension::Ext_A);
            bool_to_bits(var_2)
        };
        core_ctx.misa.bits.set_subrange::<0, 1, 1>(var_1)
    };
    core_ctx.misa.bits = {
        let var_3 = {
            let var_4 = hartSupports(core_ctx, extension::Ext_C);
            bool_to_bits(var_4)
        };
        core_ctx.misa.bits.set_subrange::<2, 3, 1>(var_3)
    };
    core_ctx.misa.bits = {
        let var_5 = {
            let var_6 = hartSupports(core_ctx, extension::Ext_B);
            bool_to_bits(var_6)
        };
        core_ctx.misa.bits.set_subrange::<1, 2, 1>(var_5)
    };
    core_ctx.misa.bits = core_ctx.misa.bits.set_subrange::<8, 9, 1>(BitVector::<1>::new(0b1));
    core_ctx.misa.bits = {
        let var_7 = {
            let var_8 = hartSupports(core_ctx, extension::Ext_M);
            bool_to_bits(var_8)
        };
        core_ctx.misa.bits.set_subrange::<12, 13, 1>(var_7)
    };
    core_ctx.misa.bits = {
        let var_9 = {
            let var_10 = hartSupports(core_ctx, extension::Ext_U);
            bool_to_bits(var_10)
        };
        core_ctx.misa.bits.set_subrange::<20, 21, 1>(var_9)
    };
    core_ctx.misa.bits = {
        let var_11 = {
            let var_12 = hartSupports(core_ctx, extension::Ext_S);
            bool_to_bits(var_12)
        };
        core_ctx.misa.bits.set_subrange::<18, 19, 1>(var_11)
    };
    core_ctx.misa.bits = {
        let var_13 = {
            let var_14 = hartSupports(core_ctx, extension::Ext_V);
            bool_to_bits(var_14)
        };
        core_ctx.misa.bits.set_subrange::<21, 22, 1>(var_13)
    };
    if {(hartSupports(core_ctx, extension::Ext_F) && hartSupports(core_ctx, extension::Ext_Zfinx))} {
        panic!("{}, l {}: {}", "riscv_sys_control.sail", 352, "F and Zfinx cannot both be enabled!")
    } else {
        ()
    };
    core_ctx.misa.bits = {
        let var_15 = {
            let var_16 = hartSupports(core_ctx, extension::Ext_F);
            bool_to_bits(var_16)
        };
        core_ctx.misa.bits.set_subrange::<5, 6, 1>(var_15)
    };
    core_ctx.misa.bits = {
        let var_17 = {
            let var_18 = hartSupports(core_ctx, extension::Ext_D);
            bool_to_bits(var_18)
        };
        core_ctx.misa.bits.set_subrange::<3, 4, 1>(var_17)
    }
}

/// reset_sys
/// 
/// Generated from the Sail sources at `riscv_sys_control.sail` L364-417.
pub fn reset_sys(core_ctx: &mut Core, unit_arg: ()) {
    core_ctx.cur_privilege = Privilege::Machine;
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<3, 4, 1>(BitVector::<1>::new(0b0));
    core_ctx.mstatus.bits = core_ctx.mstatus.bits.set_subrange::<17, 18, 1>(BitVector::<1>::new(0b0));
    reset_misa(core_ctx, ());
    cancel_reservation(());
    core_ctx.mcause.bits = zeros::<64>(64);
    reset_pmp(core_ctx, ());
    core_ctx.vstart = zeros::<16>(16);
    core_ctx.vl = zeros::<64>(64);
    core_ctx.vcsr.bits = core_ctx.vcsr.bits.set_subrange::<1, 3, 2>(BitVector::<2>::new(0b00));
    core_ctx.vcsr.bits = core_ctx.vcsr.bits.set_subrange::<0, 1, 1>(BitVector::<1>::new(0b0));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<63, 64, 1>(BitVector::<1>::new(0b1));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<8, 63, 55>(zeros::<55>(55));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<7, 8, 1>(BitVector::<1>::new(0b0));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<6, 7, 1>(BitVector::<1>::new(0b0));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<3, 6, 3>(BitVector::<3>::new(0b000));
    core_ctx.vtype.bits = core_ctx.vtype.bits.set_subrange::<0, 3, 3>(BitVector::<3>::new(0b000))
}

pub type MemoryOpResult<A> = result<A, ExceptionType>;

/// plat_cache_block_size_exp
/// 
/// Generated from the Sail sources at `riscv_platform.sail` L31.
pub fn plat_cache_block_size_exp(core_ctx: &mut Core, unit_arg: ()) -> i128 {
    core_ctx.config.platform.cache_block_size_exp
}

/// plat_mtval_has_illegal_inst_bits
/// 
/// Generated from the Sail sources at `riscv_platform.sail` L46.
pub fn plat_mtval_has_illegal_inst_bits(core_ctx: &mut Core, unit_arg: ()) -> bool {
    core_ctx.config.base.mtval_has_illegal_instruction_bits
}

pub const MSIP_BASE: physaddrbits = BitVector::<20>::new(0b00000000000000000000).zero_extend::<64>();

pub const MTIMECMP_BASE: physaddrbits = BitVector::<20>::new(0b00000100000000000000).zero_extend::<64>();

pub const MTIMECMP_BASE_HI: physaddrbits = BitVector::<20>::new(0b00000100000000000100).zero_extend::<64>();

pub const MTIME_BASE: physaddrbits = BitVector::<20>::new(0b00001011111111111000).zero_extend::<64>();

pub const MTIME_BASE_HI: physaddrbits = BitVector::<20>::new(0b00001011111111111100).zero_extend::<64>();

/// handle_illegal
/// 
/// Generated from the Sail sources at `riscv_platform.sail` L448-456.
pub fn handle_illegal(core_ctx: &mut Core, instbits: BitVector<32>) {
    let info = if {plat_mtval_has_illegal_inst_bits(core_ctx, ())} {
        Some(instbits.zero_extend::<64>())
    } else {
        None
    };
    let t: sync_exception = sync_exception {
        trap: ExceptionType::E_Illegal_Instr(()),
        excinfo: info,
        ext: None
    };
    {
        let var_1 = {
            let var_2 = core_ctx.cur_privilege;
            let var_3 = core_ctx.PC;
            exception_handler(core_ctx, var_2, ctl_result::CTL_TRAP(t), var_3)
        };
        set_next_pc(core_ctx, var_1)
    }
}

/// phys_access_check
/// 
/// Generated from the Sail sources at `riscv_mem.sail` L99-103.
pub fn phys_access_check(core_ctx: &mut Core, t: AccessType<()>, p: Privilege, paddr: physaddr, width: i128) -> Option<ExceptionType> {
    let pmpError: Option<ExceptionType> = if {(sys_pmp_count(core_ctx, ()) == 0)} {
        None
    } else {
        pmpCheck(core_ctx, paddr, width, t, p)
    };
    pmpError
}

/// ExecutionResult
/// 
/// Generated from the Sail sources at `riscv_inst_retire.sail` L10-28.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum ExecutionResult {
    Retire_Success(()),
    Wait_For_Interrupt(()),
    Illegal_Instruction(()),
    Trap((Privilege, ctl_result, xlenbits)),
    Memory_Exception((virtaddr, ExceptionType)),
    Ext_CSR_Check_Failure(()),
    Ext_ControlAddr_Check_Failure(ext_control_addr_error),
    Ext_DataAddr_Check_Failure(ext_data_addr_error),
    Ext_XRET_Priv_Failure(())
}

pub const RETIRE_SUCCESS: ExecutionResult = ExecutionResult::Retire_Success(());

pub type pte_flags_bits = BitVector<8>;

pub type pte_ext_bits = BitVector<10>;

pub const default_sv32_ext_pte: pte_ext_bits = zeros::<10>(10);

/// PTE_Check
/// 
/// Generated from the Sail sources at `riscv_vmem_pte.sail` L94-97.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum PTE_Check {
    PTE_Check_Success(ext_ptw),
    PTE_Check_Failure((ext_ptw, ext_ptw_fail))
}

pub const tlb_vpn_bits: i128 = 45;

pub const tlb_ppn_bits: i128 = 44;

/// TLB_Entry
/// 
/// Generated from the Sail sources at `riscv_vmem_tlb.sail` L25-33.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct TLB_Entry {
    pub asid: asidbits,
    pub global: bool,
    pub vpn: BitVector<tlb_vpn_bits>,
    pub levelMask: BitVector<tlb_vpn_bits>,
    pub ppn: BitVector<tlb_ppn_bits>,
    pub pte: BitVector<64>,
    pub pteAddr: physaddr,
}

pub const num_tlb_entries: i128 = 64;

pub type tlb_index_range = i128;

/// flush_TLB_Entry
/// 
/// Generated from the Sail sources at `riscv_vmem_tlb.sail` L98-113.
pub fn flush_TLB_Entry(ent: TLB_Entry, asid: Option<BitVector<16>>, vaddr: Option<BitVector<{
    64
}>>) -> bool {
    let asid_matches: bool = match asid {
        Some(asid) => {((ent.asid == asid) && !(ent.global))}
        None => {true}
        _ => {panic!("Unreachable code")}
    };
    let addr_matches: bool = match vaddr {
        Some(vaddr) => {{
            let vaddr: BitVector<64> = sign_extend(64, vaddr);
            (ent.vpn == (vaddr.subrange::<12, 57, 45>() & !(ent.levelMask)))
        }}
        None => {true}
        _ => {panic!("Unreachable code")}
    };
    (asid_matches && addr_matches)
}

/// flush_TLB
/// 
/// Generated from the Sail sources at `riscv_vmem_tlb.sail` L165-173.
pub fn flush_TLB(core_ctx: &mut Core, asid: Option<BitVector<16>>, addr: Option<BitVector<{
    64
}>>) {
    for i in 0..=(core_ctx.tlb.len() - 1) {
        match core_ctx.tlb[(i as usize)] {
            None => {()}
            Some(entry) => {if {flush_TLB_Entry(entry, asid, addr)} {
                core_ctx.tlb[(i as usize)] = None
            } else {
                ()
            }}
            _ => {panic!("Unreachable code")}
        }
    }
}

/// TR_Result
/// 
/// Generated from the Sail sources at `riscv_vmem.sail` L212-215.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum TR_Result<PADDR, FAILURE> {
    TR_Address((PADDR, ext_ptw)),
    TR_Failure((FAILURE, ext_ptw))
}

pub const sm4_sbox_table: [BitVector<8>; (256 as usize)] = [BitVector::<8>::new(0b11010110), BitVector::<8>::new(0b10010000), BitVector::<8>::new(0b11101001), BitVector::<8>::new(0b11111110), BitVector::<8>::new(0b11001100), BitVector::<8>::new(0b11100001), BitVector::<8>::new(0b00111101), BitVector::<8>::new(0b10110111), BitVector::<8>::new(0b00010110), BitVector::<8>::new(0b10110110), BitVector::<8>::new(0b00010100), BitVector::<8>::new(0b11000010), BitVector::<8>::new(0b00101000), BitVector::<8>::new(0b11111011), BitVector::<8>::new(0b00101100), BitVector::<8>::new(0b00000101), BitVector::<8>::new(0b00101011), BitVector::<8>::new(0b01100111), BitVector::<8>::new(0b10011010), BitVector::<8>::new(0b01110110), BitVector::<8>::new(0b00101010), BitVector::<8>::new(0b10111110), BitVector::<8>::new(0b00000100), BitVector::<8>::new(0b11000011), BitVector::<8>::new(0b10101010), BitVector::<8>::new(0b01000100), BitVector::<8>::new(0b00010011), BitVector::<8>::new(0b00100110), BitVector::<8>::new(0b01001001), BitVector::<8>::new(0b10000110), BitVector::<8>::new(0b00000110), BitVector::<8>::new(0b10011001), BitVector::<8>::new(0b10011100), BitVector::<8>::new(0b01000010), BitVector::<8>::new(0b01010000), BitVector::<8>::new(0b11110100), BitVector::<8>::new(0b10010001), BitVector::<8>::new(0b11101111), BitVector::<8>::new(0b10011000), BitVector::<8>::new(0b01111010), BitVector::<8>::new(0b00110011), BitVector::<8>::new(0b01010100), BitVector::<8>::new(0b00001011), BitVector::<8>::new(0b01000011), BitVector::<8>::new(0b11101101), BitVector::<8>::new(0b11001111), BitVector::<8>::new(0b10101100), BitVector::<8>::new(0b01100010), BitVector::<8>::new(0b11100100), BitVector::<8>::new(0b10110011), BitVector::<8>::new(0b00011100), BitVector::<8>::new(0b10101001), BitVector::<8>::new(0b11001001), BitVector::<8>::new(0b00001000), BitVector::<8>::new(0b11101000), BitVector::<8>::new(0b10010101), BitVector::<8>::new(0b10000000), BitVector::<8>::new(0b11011111), BitVector::<8>::new(0b10010100), BitVector::<8>::new(0b11111010), BitVector::<8>::new(0b01110101), BitVector::<8>::new(0b10001111), BitVector::<8>::new(0b00111111), BitVector::<8>::new(0b10100110), BitVector::<8>::new(0b01000111), BitVector::<8>::new(0b00000111), BitVector::<8>::new(0b10100111), BitVector::<8>::new(0b11111100), BitVector::<8>::new(0b11110011), BitVector::<8>::new(0b01110011), BitVector::<8>::new(0b00010111), BitVector::<8>::new(0b10111010), BitVector::<8>::new(0b10000011), BitVector::<8>::new(0b01011001), BitVector::<8>::new(0b00111100), BitVector::<8>::new(0b00011001), BitVector::<8>::new(0b11100110), BitVector::<8>::new(0b10000101), BitVector::<8>::new(0b01001111), BitVector::<8>::new(0b10101000), BitVector::<8>::new(0b01101000), BitVector::<8>::new(0b01101011), BitVector::<8>::new(0b10000001), BitVector::<8>::new(0b10110010), BitVector::<8>::new(0b01110001), BitVector::<8>::new(0b01100100), BitVector::<8>::new(0b11011010), BitVector::<8>::new(0b10001011), BitVector::<8>::new(0b11111000), BitVector::<8>::new(0b11101011), BitVector::<8>::new(0b00001111), BitVector::<8>::new(0b01001011), BitVector::<8>::new(0b01110000), BitVector::<8>::new(0b01010110), BitVector::<8>::new(0b10011101), BitVector::<8>::new(0b00110101), BitVector::<8>::new(0b00011110), BitVector::<8>::new(0b00100100), BitVector::<8>::new(0b00001110), BitVector::<8>::new(0b01011110), BitVector::<8>::new(0b01100011), BitVector::<8>::new(0b01011000), BitVector::<8>::new(0b11010001), BitVector::<8>::new(0b10100010), BitVector::<8>::new(0b00100101), BitVector::<8>::new(0b00100010), BitVector::<8>::new(0b01111100), BitVector::<8>::new(0b00111011), BitVector::<8>::new(0b00000001), BitVector::<8>::new(0b00100001), BitVector::<8>::new(0b01111000), BitVector::<8>::new(0b10000111), BitVector::<8>::new(0b11010100), BitVector::<8>::new(0b00000000), BitVector::<8>::new(0b01000110), BitVector::<8>::new(0b01010111), BitVector::<8>::new(0b10011111), BitVector::<8>::new(0b11010011), BitVector::<8>::new(0b00100111), BitVector::<8>::new(0b01010010), BitVector::<8>::new(0b01001100), BitVector::<8>::new(0b00110110), BitVector::<8>::new(0b00000010), BitVector::<8>::new(0b11100111), BitVector::<8>::new(0b10100000), BitVector::<8>::new(0b11000100), BitVector::<8>::new(0b11001000), BitVector::<8>::new(0b10011110), BitVector::<8>::new(0b11101010), BitVector::<8>::new(0b10111111), BitVector::<8>::new(0b10001010), BitVector::<8>::new(0b11010010), BitVector::<8>::new(0b01000000), BitVector::<8>::new(0b11000111), BitVector::<8>::new(0b00111000), BitVector::<8>::new(0b10110101), BitVector::<8>::new(0b10100011), BitVector::<8>::new(0b11110111), BitVector::<8>::new(0b11110010), BitVector::<8>::new(0b11001110), BitVector::<8>::new(0b11111001), BitVector::<8>::new(0b01100001), BitVector::<8>::new(0b00010101), BitVector::<8>::new(0b10100001), BitVector::<8>::new(0b11100000), BitVector::<8>::new(0b10101110), BitVector::<8>::new(0b01011101), BitVector::<8>::new(0b10100100), BitVector::<8>::new(0b10011011), BitVector::<8>::new(0b00110100), BitVector::<8>::new(0b00011010), BitVector::<8>::new(0b01010101), BitVector::<8>::new(0b10101101), BitVector::<8>::new(0b10010011), BitVector::<8>::new(0b00110010), BitVector::<8>::new(0b00110000), BitVector::<8>::new(0b11110101), BitVector::<8>::new(0b10001100), BitVector::<8>::new(0b10110001), BitVector::<8>::new(0b11100011), BitVector::<8>::new(0b00011101), BitVector::<8>::new(0b11110110), BitVector::<8>::new(0b11100010), BitVector::<8>::new(0b00101110), BitVector::<8>::new(0b10000010), BitVector::<8>::new(0b01100110), BitVector::<8>::new(0b11001010), BitVector::<8>::new(0b01100000), BitVector::<8>::new(0b11000000), BitVector::<8>::new(0b00101001), BitVector::<8>::new(0b00100011), BitVector::<8>::new(0b10101011), BitVector::<8>::new(0b00001101), BitVector::<8>::new(0b01010011), BitVector::<8>::new(0b01001110), BitVector::<8>::new(0b01101111), BitVector::<8>::new(0b11010101), BitVector::<8>::new(0b11011011), BitVector::<8>::new(0b00110111), BitVector::<8>::new(0b01000101), BitVector::<8>::new(0b11011110), BitVector::<8>::new(0b11111101), BitVector::<8>::new(0b10001110), BitVector::<8>::new(0b00101111), BitVector::<8>::new(0b00000011), BitVector::<8>::new(0b11111111), BitVector::<8>::new(0b01101010), BitVector::<8>::new(0b01110010), BitVector::<8>::new(0b01101101), BitVector::<8>::new(0b01101100), BitVector::<8>::new(0b01011011), BitVector::<8>::new(0b01010001), BitVector::<8>::new(0b10001101), BitVector::<8>::new(0b00011011), BitVector::<8>::new(0b10101111), BitVector::<8>::new(0b10010010), BitVector::<8>::new(0b10111011), BitVector::<8>::new(0b11011101), BitVector::<8>::new(0b10111100), BitVector::<8>::new(0b01111111), BitVector::<8>::new(0b00010001), BitVector::<8>::new(0b11011001), BitVector::<8>::new(0b01011100), BitVector::<8>::new(0b01000001), BitVector::<8>::new(0b00011111), BitVector::<8>::new(0b00010000), BitVector::<8>::new(0b01011010), BitVector::<8>::new(0b11011000), BitVector::<8>::new(0b00001010), BitVector::<8>::new(0b11000001), BitVector::<8>::new(0b00110001), BitVector::<8>::new(0b10001000), BitVector::<8>::new(0b10100101), BitVector::<8>::new(0b11001101), BitVector::<8>::new(0b01111011), BitVector::<8>::new(0b10111101), BitVector::<8>::new(0b00101101), BitVector::<8>::new(0b01110100), BitVector::<8>::new(0b11010000), BitVector::<8>::new(0b00010010), BitVector::<8>::new(0b10111000), BitVector::<8>::new(0b11100101), BitVector::<8>::new(0b10110100), BitVector::<8>::new(0b10110000), BitVector::<8>::new(0b10001001), BitVector::<8>::new(0b01101001), BitVector::<8>::new(0b10010111), BitVector::<8>::new(0b01001010), BitVector::<8>::new(0b00001100), BitVector::<8>::new(0b10010110), BitVector::<8>::new(0b01110111), BitVector::<8>::new(0b01111110), BitVector::<8>::new(0b01100101), BitVector::<8>::new(0b10111001), BitVector::<8>::new(0b11110001), BitVector::<8>::new(0b00001001), BitVector::<8>::new(0b11000101), BitVector::<8>::new(0b01101110), BitVector::<8>::new(0b11000110), BitVector::<8>::new(0b10000100), BitVector::<8>::new(0b00011000), BitVector::<8>::new(0b11110000), BitVector::<8>::new(0b01111101), BitVector::<8>::new(0b11101100), BitVector::<8>::new(0b00111010), BitVector::<8>::new(0b11011100), BitVector::<8>::new(0b01001101), BitVector::<8>::new(0b00100000), BitVector::<8>::new(0b01111001), BitVector::<8>::new(0b11101110), BitVector::<8>::new(0b01011111), BitVector::<8>::new(0b00111110), BitVector::<8>::new(0b11010111), BitVector::<8>::new(0b11001011), BitVector::<8>::new(0b00111001), BitVector::<8>::new(0b01001000)];

pub const aes_sbox_fwd_table: [BitVector<8>; (256 as usize)] = [BitVector::<8>::new(0b01100011), BitVector::<8>::new(0b01111100), BitVector::<8>::new(0b01110111), BitVector::<8>::new(0b01111011), BitVector::<8>::new(0b11110010), BitVector::<8>::new(0b01101011), BitVector::<8>::new(0b01101111), BitVector::<8>::new(0b11000101), BitVector::<8>::new(0b00110000), BitVector::<8>::new(0b00000001), BitVector::<8>::new(0b01100111), BitVector::<8>::new(0b00101011), BitVector::<8>::new(0b11111110), BitVector::<8>::new(0b11010111), BitVector::<8>::new(0b10101011), BitVector::<8>::new(0b01110110), BitVector::<8>::new(0b11001010), BitVector::<8>::new(0b10000010), BitVector::<8>::new(0b11001001), BitVector::<8>::new(0b01111101), BitVector::<8>::new(0b11111010), BitVector::<8>::new(0b01011001), BitVector::<8>::new(0b01000111), BitVector::<8>::new(0b11110000), BitVector::<8>::new(0b10101101), BitVector::<8>::new(0b11010100), BitVector::<8>::new(0b10100010), BitVector::<8>::new(0b10101111), BitVector::<8>::new(0b10011100), BitVector::<8>::new(0b10100100), BitVector::<8>::new(0b01110010), BitVector::<8>::new(0b11000000), BitVector::<8>::new(0b10110111), BitVector::<8>::new(0b11111101), BitVector::<8>::new(0b10010011), BitVector::<8>::new(0b00100110), BitVector::<8>::new(0b00110110), BitVector::<8>::new(0b00111111), BitVector::<8>::new(0b11110111), BitVector::<8>::new(0b11001100), BitVector::<8>::new(0b00110100), BitVector::<8>::new(0b10100101), BitVector::<8>::new(0b11100101), BitVector::<8>::new(0b11110001), BitVector::<8>::new(0b01110001), BitVector::<8>::new(0b11011000), BitVector::<8>::new(0b00110001), BitVector::<8>::new(0b00010101), BitVector::<8>::new(0b00000100), BitVector::<8>::new(0b11000111), BitVector::<8>::new(0b00100011), BitVector::<8>::new(0b11000011), BitVector::<8>::new(0b00011000), BitVector::<8>::new(0b10010110), BitVector::<8>::new(0b00000101), BitVector::<8>::new(0b10011010), BitVector::<8>::new(0b00000111), BitVector::<8>::new(0b00010010), BitVector::<8>::new(0b10000000), BitVector::<8>::new(0b11100010), BitVector::<8>::new(0b11101011), BitVector::<8>::new(0b00100111), BitVector::<8>::new(0b10110010), BitVector::<8>::new(0b01110101), BitVector::<8>::new(0b00001001), BitVector::<8>::new(0b10000011), BitVector::<8>::new(0b00101100), BitVector::<8>::new(0b00011010), BitVector::<8>::new(0b00011011), BitVector::<8>::new(0b01101110), BitVector::<8>::new(0b01011010), BitVector::<8>::new(0b10100000), BitVector::<8>::new(0b01010010), BitVector::<8>::new(0b00111011), BitVector::<8>::new(0b11010110), BitVector::<8>::new(0b10110011), BitVector::<8>::new(0b00101001), BitVector::<8>::new(0b11100011), BitVector::<8>::new(0b00101111), BitVector::<8>::new(0b10000100), BitVector::<8>::new(0b01010011), BitVector::<8>::new(0b11010001), BitVector::<8>::new(0b00000000), BitVector::<8>::new(0b11101101), BitVector::<8>::new(0b00100000), BitVector::<8>::new(0b11111100), BitVector::<8>::new(0b10110001), BitVector::<8>::new(0b01011011), BitVector::<8>::new(0b01101010), BitVector::<8>::new(0b11001011), BitVector::<8>::new(0b10111110), BitVector::<8>::new(0b00111001), BitVector::<8>::new(0b01001010), BitVector::<8>::new(0b01001100), BitVector::<8>::new(0b01011000), BitVector::<8>::new(0b11001111), BitVector::<8>::new(0b11010000), BitVector::<8>::new(0b11101111), BitVector::<8>::new(0b10101010), BitVector::<8>::new(0b11111011), BitVector::<8>::new(0b01000011), BitVector::<8>::new(0b01001101), BitVector::<8>::new(0b00110011), BitVector::<8>::new(0b10000101), BitVector::<8>::new(0b01000101), BitVector::<8>::new(0b11111001), BitVector::<8>::new(0b00000010), BitVector::<8>::new(0b01111111), BitVector::<8>::new(0b01010000), BitVector::<8>::new(0b00111100), BitVector::<8>::new(0b10011111), BitVector::<8>::new(0b10101000), BitVector::<8>::new(0b01010001), BitVector::<8>::new(0b10100011), BitVector::<8>::new(0b01000000), BitVector::<8>::new(0b10001111), BitVector::<8>::new(0b10010010), BitVector::<8>::new(0b10011101), BitVector::<8>::new(0b00111000), BitVector::<8>::new(0b11110101), BitVector::<8>::new(0b10111100), BitVector::<8>::new(0b10110110), BitVector::<8>::new(0b11011010), BitVector::<8>::new(0b00100001), BitVector::<8>::new(0b00010000), BitVector::<8>::new(0b11111111), BitVector::<8>::new(0b11110011), BitVector::<8>::new(0b11010010), BitVector::<8>::new(0b11001101), BitVector::<8>::new(0b00001100), BitVector::<8>::new(0b00010011), BitVector::<8>::new(0b11101100), BitVector::<8>::new(0b01011111), BitVector::<8>::new(0b10010111), BitVector::<8>::new(0b01000100), BitVector::<8>::new(0b00010111), BitVector::<8>::new(0b11000100), BitVector::<8>::new(0b10100111), BitVector::<8>::new(0b01111110), BitVector::<8>::new(0b00111101), BitVector::<8>::new(0b01100100), BitVector::<8>::new(0b01011101), BitVector::<8>::new(0b00011001), BitVector::<8>::new(0b01110011), BitVector::<8>::new(0b01100000), BitVector::<8>::new(0b10000001), BitVector::<8>::new(0b01001111), BitVector::<8>::new(0b11011100), BitVector::<8>::new(0b00100010), BitVector::<8>::new(0b00101010), BitVector::<8>::new(0b10010000), BitVector::<8>::new(0b10001000), BitVector::<8>::new(0b01000110), BitVector::<8>::new(0b11101110), BitVector::<8>::new(0b10111000), BitVector::<8>::new(0b00010100), BitVector::<8>::new(0b11011110), BitVector::<8>::new(0b01011110), BitVector::<8>::new(0b00001011), BitVector::<8>::new(0b11011011), BitVector::<8>::new(0b11100000), BitVector::<8>::new(0b00110010), BitVector::<8>::new(0b00111010), BitVector::<8>::new(0b00001010), BitVector::<8>::new(0b01001001), BitVector::<8>::new(0b00000110), BitVector::<8>::new(0b00100100), BitVector::<8>::new(0b01011100), BitVector::<8>::new(0b11000010), BitVector::<8>::new(0b11010011), BitVector::<8>::new(0b10101100), BitVector::<8>::new(0b01100010), BitVector::<8>::new(0b10010001), BitVector::<8>::new(0b10010101), BitVector::<8>::new(0b11100100), BitVector::<8>::new(0b01111001), BitVector::<8>::new(0b11100111), BitVector::<8>::new(0b11001000), BitVector::<8>::new(0b00110111), BitVector::<8>::new(0b01101101), BitVector::<8>::new(0b10001101), BitVector::<8>::new(0b11010101), BitVector::<8>::new(0b01001110), BitVector::<8>::new(0b10101001), BitVector::<8>::new(0b01101100), BitVector::<8>::new(0b01010110), BitVector::<8>::new(0b11110100), BitVector::<8>::new(0b11101010), BitVector::<8>::new(0b01100101), BitVector::<8>::new(0b01111010), BitVector::<8>::new(0b10101110), BitVector::<8>::new(0b00001000), BitVector::<8>::new(0b10111010), BitVector::<8>::new(0b01111000), BitVector::<8>::new(0b00100101), BitVector::<8>::new(0b00101110), BitVector::<8>::new(0b00011100), BitVector::<8>::new(0b10100110), BitVector::<8>::new(0b10110100), BitVector::<8>::new(0b11000110), BitVector::<8>::new(0b11101000), BitVector::<8>::new(0b11011101), BitVector::<8>::new(0b01110100), BitVector::<8>::new(0b00011111), BitVector::<8>::new(0b01001011), BitVector::<8>::new(0b10111101), BitVector::<8>::new(0b10001011), BitVector::<8>::new(0b10001010), BitVector::<8>::new(0b01110000), BitVector::<8>::new(0b00111110), BitVector::<8>::new(0b10110101), BitVector::<8>::new(0b01100110), BitVector::<8>::new(0b01001000), BitVector::<8>::new(0b00000011), BitVector::<8>::new(0b11110110), BitVector::<8>::new(0b00001110), BitVector::<8>::new(0b01100001), BitVector::<8>::new(0b00110101), BitVector::<8>::new(0b01010111), BitVector::<8>::new(0b10111001), BitVector::<8>::new(0b10000110), BitVector::<8>::new(0b11000001), BitVector::<8>::new(0b00011101), BitVector::<8>::new(0b10011110), BitVector::<8>::new(0b11100001), BitVector::<8>::new(0b11111000), BitVector::<8>::new(0b10011000), BitVector::<8>::new(0b00010001), BitVector::<8>::new(0b01101001), BitVector::<8>::new(0b11011001), BitVector::<8>::new(0b10001110), BitVector::<8>::new(0b10010100), BitVector::<8>::new(0b10011011), BitVector::<8>::new(0b00011110), BitVector::<8>::new(0b10000111), BitVector::<8>::new(0b11101001), BitVector::<8>::new(0b11001110), BitVector::<8>::new(0b01010101), BitVector::<8>::new(0b00101000), BitVector::<8>::new(0b11011111), BitVector::<8>::new(0b10001100), BitVector::<8>::new(0b10100001), BitVector::<8>::new(0b10001001), BitVector::<8>::new(0b00001101), BitVector::<8>::new(0b10111111), BitVector::<8>::new(0b11100110), BitVector::<8>::new(0b01000010), BitVector::<8>::new(0b01101000), BitVector::<8>::new(0b01000001), BitVector::<8>::new(0b10011001), BitVector::<8>::new(0b00101101), BitVector::<8>::new(0b00001111), BitVector::<8>::new(0b10110000), BitVector::<8>::new(0b01010100), BitVector::<8>::new(0b10111011), BitVector::<8>::new(0b00010110)];

pub const aes_sbox_inv_table: [BitVector<8>; (256 as usize)] = [BitVector::<8>::new(0b01010010), BitVector::<8>::new(0b00001001), BitVector::<8>::new(0b01101010), BitVector::<8>::new(0b11010101), BitVector::<8>::new(0b00110000), BitVector::<8>::new(0b00110110), BitVector::<8>::new(0b10100101), BitVector::<8>::new(0b00111000), BitVector::<8>::new(0b10111111), BitVector::<8>::new(0b01000000), BitVector::<8>::new(0b10100011), BitVector::<8>::new(0b10011110), BitVector::<8>::new(0b10000001), BitVector::<8>::new(0b11110011), BitVector::<8>::new(0b11010111), BitVector::<8>::new(0b11111011), BitVector::<8>::new(0b01111100), BitVector::<8>::new(0b11100011), BitVector::<8>::new(0b00111001), BitVector::<8>::new(0b10000010), BitVector::<8>::new(0b10011011), BitVector::<8>::new(0b00101111), BitVector::<8>::new(0b11111111), BitVector::<8>::new(0b10000111), BitVector::<8>::new(0b00110100), BitVector::<8>::new(0b10001110), BitVector::<8>::new(0b01000011), BitVector::<8>::new(0b01000100), BitVector::<8>::new(0b11000100), BitVector::<8>::new(0b11011110), BitVector::<8>::new(0b11101001), BitVector::<8>::new(0b11001011), BitVector::<8>::new(0b01010100), BitVector::<8>::new(0b01111011), BitVector::<8>::new(0b10010100), BitVector::<8>::new(0b00110010), BitVector::<8>::new(0b10100110), BitVector::<8>::new(0b11000010), BitVector::<8>::new(0b00100011), BitVector::<8>::new(0b00111101), BitVector::<8>::new(0b11101110), BitVector::<8>::new(0b01001100), BitVector::<8>::new(0b10010101), BitVector::<8>::new(0b00001011), BitVector::<8>::new(0b01000010), BitVector::<8>::new(0b11111010), BitVector::<8>::new(0b11000011), BitVector::<8>::new(0b01001110), BitVector::<8>::new(0b00001000), BitVector::<8>::new(0b00101110), BitVector::<8>::new(0b10100001), BitVector::<8>::new(0b01100110), BitVector::<8>::new(0b00101000), BitVector::<8>::new(0b11011001), BitVector::<8>::new(0b00100100), BitVector::<8>::new(0b10110010), BitVector::<8>::new(0b01110110), BitVector::<8>::new(0b01011011), BitVector::<8>::new(0b10100010), BitVector::<8>::new(0b01001001), BitVector::<8>::new(0b01101101), BitVector::<8>::new(0b10001011), BitVector::<8>::new(0b11010001), BitVector::<8>::new(0b00100101), BitVector::<8>::new(0b01110010), BitVector::<8>::new(0b11111000), BitVector::<8>::new(0b11110110), BitVector::<8>::new(0b01100100), BitVector::<8>::new(0b10000110), BitVector::<8>::new(0b01101000), BitVector::<8>::new(0b10011000), BitVector::<8>::new(0b00010110), BitVector::<8>::new(0b11010100), BitVector::<8>::new(0b10100100), BitVector::<8>::new(0b01011100), BitVector::<8>::new(0b11001100), BitVector::<8>::new(0b01011101), BitVector::<8>::new(0b01100101), BitVector::<8>::new(0b10110110), BitVector::<8>::new(0b10010010), BitVector::<8>::new(0b01101100), BitVector::<8>::new(0b01110000), BitVector::<8>::new(0b01001000), BitVector::<8>::new(0b01010000), BitVector::<8>::new(0b11111101), BitVector::<8>::new(0b11101101), BitVector::<8>::new(0b10111001), BitVector::<8>::new(0b11011010), BitVector::<8>::new(0b01011110), BitVector::<8>::new(0b00010101), BitVector::<8>::new(0b01000110), BitVector::<8>::new(0b01010111), BitVector::<8>::new(0b10100111), BitVector::<8>::new(0b10001101), BitVector::<8>::new(0b10011101), BitVector::<8>::new(0b10000100), BitVector::<8>::new(0b10010000), BitVector::<8>::new(0b11011000), BitVector::<8>::new(0b10101011), BitVector::<8>::new(0b00000000), BitVector::<8>::new(0b10001100), BitVector::<8>::new(0b10111100), BitVector::<8>::new(0b11010011), BitVector::<8>::new(0b00001010), BitVector::<8>::new(0b11110111), BitVector::<8>::new(0b11100100), BitVector::<8>::new(0b01011000), BitVector::<8>::new(0b00000101), BitVector::<8>::new(0b10111000), BitVector::<8>::new(0b10110011), BitVector::<8>::new(0b01000101), BitVector::<8>::new(0b00000110), BitVector::<8>::new(0b11010000), BitVector::<8>::new(0b00101100), BitVector::<8>::new(0b00011110), BitVector::<8>::new(0b10001111), BitVector::<8>::new(0b11001010), BitVector::<8>::new(0b00111111), BitVector::<8>::new(0b00001111), BitVector::<8>::new(0b00000010), BitVector::<8>::new(0b11000001), BitVector::<8>::new(0b10101111), BitVector::<8>::new(0b10111101), BitVector::<8>::new(0b00000011), BitVector::<8>::new(0b00000001), BitVector::<8>::new(0b00010011), BitVector::<8>::new(0b10001010), BitVector::<8>::new(0b01101011), BitVector::<8>::new(0b00111010), BitVector::<8>::new(0b10010001), BitVector::<8>::new(0b00010001), BitVector::<8>::new(0b01000001), BitVector::<8>::new(0b01001111), BitVector::<8>::new(0b01100111), BitVector::<8>::new(0b11011100), BitVector::<8>::new(0b11101010), BitVector::<8>::new(0b10010111), BitVector::<8>::new(0b11110010), BitVector::<8>::new(0b11001111), BitVector::<8>::new(0b11001110), BitVector::<8>::new(0b11110000), BitVector::<8>::new(0b10110100), BitVector::<8>::new(0b11100110), BitVector::<8>::new(0b01110011), BitVector::<8>::new(0b10010110), BitVector::<8>::new(0b10101100), BitVector::<8>::new(0b01110100), BitVector::<8>::new(0b00100010), BitVector::<8>::new(0b11100111), BitVector::<8>::new(0b10101101), BitVector::<8>::new(0b00110101), BitVector::<8>::new(0b10000101), BitVector::<8>::new(0b11100010), BitVector::<8>::new(0b11111001), BitVector::<8>::new(0b00110111), BitVector::<8>::new(0b11101000), BitVector::<8>::new(0b00011100), BitVector::<8>::new(0b01110101), BitVector::<8>::new(0b11011111), BitVector::<8>::new(0b01101110), BitVector::<8>::new(0b01000111), BitVector::<8>::new(0b11110001), BitVector::<8>::new(0b00011010), BitVector::<8>::new(0b01110001), BitVector::<8>::new(0b00011101), BitVector::<8>::new(0b00101001), BitVector::<8>::new(0b11000101), BitVector::<8>::new(0b10001001), BitVector::<8>::new(0b01101111), BitVector::<8>::new(0b10110111), BitVector::<8>::new(0b01100010), BitVector::<8>::new(0b00001110), BitVector::<8>::new(0b10101010), BitVector::<8>::new(0b00011000), BitVector::<8>::new(0b10111110), BitVector::<8>::new(0b00011011), BitVector::<8>::new(0b11111100), BitVector::<8>::new(0b01010110), BitVector::<8>::new(0b00111110), BitVector::<8>::new(0b01001011), BitVector::<8>::new(0b11000110), BitVector::<8>::new(0b11010010), BitVector::<8>::new(0b01111001), BitVector::<8>::new(0b00100000), BitVector::<8>::new(0b10011010), BitVector::<8>::new(0b11011011), BitVector::<8>::new(0b11000000), BitVector::<8>::new(0b11111110), BitVector::<8>::new(0b01111000), BitVector::<8>::new(0b11001101), BitVector::<8>::new(0b01011010), BitVector::<8>::new(0b11110100), BitVector::<8>::new(0b00011111), BitVector::<8>::new(0b11011101), BitVector::<8>::new(0b10101000), BitVector::<8>::new(0b00110011), BitVector::<8>::new(0b10001000), BitVector::<8>::new(0b00000111), BitVector::<8>::new(0b11000111), BitVector::<8>::new(0b00110001), BitVector::<8>::new(0b10110001), BitVector::<8>::new(0b00010010), BitVector::<8>::new(0b00010000), BitVector::<8>::new(0b01011001), BitVector::<8>::new(0b00100111), BitVector::<8>::new(0b10000000), BitVector::<8>::new(0b11101100), BitVector::<8>::new(0b01011111), BitVector::<8>::new(0b01100000), BitVector::<8>::new(0b01010001), BitVector::<8>::new(0b01111111), BitVector::<8>::new(0b10101001), BitVector::<8>::new(0b00011001), BitVector::<8>::new(0b10110101), BitVector::<8>::new(0b01001010), BitVector::<8>::new(0b00001101), BitVector::<8>::new(0b00101101), BitVector::<8>::new(0b11100101), BitVector::<8>::new(0b01111010), BitVector::<8>::new(0b10011111), BitVector::<8>::new(0b10010011), BitVector::<8>::new(0b11001001), BitVector::<8>::new(0b10011100), BitVector::<8>::new(0b11101111), BitVector::<8>::new(0b10100000), BitVector::<8>::new(0b11100000), BitVector::<8>::new(0b00111011), BitVector::<8>::new(0b01001101), BitVector::<8>::new(0b10101110), BitVector::<8>::new(0b00101010), BitVector::<8>::new(0b11110101), BitVector::<8>::new(0b10110000), BitVector::<8>::new(0b11001000), BitVector::<8>::new(0b11101011), BitVector::<8>::new(0b10111011), BitVector::<8>::new(0b00111100), BitVector::<8>::new(0b10000011), BitVector::<8>::new(0b01010011), BitVector::<8>::new(0b10011001), BitVector::<8>::new(0b01100001), BitVector::<8>::new(0b00010111), BitVector::<8>::new(0b00101011), BitVector::<8>::new(0b00000100), BitVector::<8>::new(0b01111110), BitVector::<8>::new(0b10111010), BitVector::<8>::new(0b01110111), BitVector::<8>::new(0b11010110), BitVector::<8>::new(0b00100110), BitVector::<8>::new(0b11100001), BitVector::<8>::new(0b01101001), BitVector::<8>::new(0b00010100), BitVector::<8>::new(0b01100011), BitVector::<8>::new(0b01010101), BitVector::<8>::new(0b00100001), BitVector::<8>::new(0b00001100), BitVector::<8>::new(0b01111101)];

/// sbox_lookup
/// 
/// Generated from the Sail sources at `riscv_types_kext.sail` L178-180.
pub fn sbox_lookup(x: BitVector<8>, table: [BitVector<8>; (256 as usize)]) -> BitVector<8> {
    table[((255 - x.unsigned()) as usize)]
}

/// sm4_sbox
/// 
/// Generated from the Sail sources at `riscv_types_kext.sail` L214.
pub fn sm4_sbox(x: BitVector<8>) -> BitVector<8> {
    sbox_lookup(x, sm4_sbox_table)
}

/// zvk_valid_reg_overlap
/// 
/// Generated from the Sail sources at `riscv_zvk_utils.sail` L10-15.
pub fn zvk_valid_reg_overlap(rs: vregidx, rd: vregidx, emul_pow: i128) -> bool {
    let reg_group_size = if {(emul_pow > 0)} {
        i128::pow(2, (emul_pow as u32))
    } else {
        1
    };
    let rs_int = vregidx_bits(rs).unsigned();
    let rd_int = vregidx_bits(rd).unsigned();
    (((rs_int + reg_group_size) <= rd_int) || ((rd_int + reg_group_size) <= rs_int))
}

/// zvk_check_encdec
/// 
/// Generated from the Sail sources at `riscv_zvk_utils.sail` L17-21.
pub fn zvk_check_encdec(core_ctx: &mut Core, EGW: i128, EGS: i128) -> bool {
    let LMUL_pow = get_lmul_pow(core_ctx, ());
    let LMUL_times_VLEN: i128 = if {(LMUL_pow < 0)} {
        (8 / i128::pow(2, (i128::abs(LMUL_pow) as u32)))
    } else {
        (i128::pow(2, (LMUL_pow as u32)) * 8)
    };
    ((((core_ctx.vl.unsigned() as usize) % (EGS as usize)) == 0) && (((((core_ctx.vstart.unsigned() as usize) % (EGS as usize)) == 0) && (LMUL_times_VLEN >= EGW)) as bool))
}

/// zvknhab_check_encdec
/// 
/// Generated from the Sail sources at `riscv_zvk_utils.sail` L30-34.
pub fn zvknhab_check_encdec(core_ctx: &mut Core, vs2: vregidx, vs1: vregidx, vd: vregidx) -> bool {
    let SEW = get_sew(core_ctx, ());
    let LMUL_pow = get_lmul_pow(core_ctx, ());
    (zvk_check_encdec(core_ctx, SEW, 4) && (zvk_valid_reg_overlap(vs1, vd, LMUL_pow) && zvk_valid_reg_overlap(vs2, vd, LMUL_pow)))
}

/// encdec_uop_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_uop_forwards(arg_hashtag_: uop) -> BitVector<7> {
    match arg_hashtag_ {
        uop::LUI => {BitVector::<7>::new(0b0110111)}
        uop::AUIPC => {BitVector::<7>::new(0b0010111)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_uop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_uop_backwards(arg_hashtag_: BitVector<7>) -> uop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<7>::new(0b0110111))} => {uop::LUI}
        b__1 if {(b__1 == BitVector::<7>::new(0b0010111))} => {uop::AUIPC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_uop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_uop_backwards_matches(arg_hashtag_: BitVector<7>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<7>::new(0b0110111))} => {true}
        b__1 if {(b__1 == BitVector::<7>::new(0b0010111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_bop_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_bop_forwards(arg_hashtag_: bop) -> BitVector<3> {
    match arg_hashtag_ {
        bop::BEQ => {BitVector::<3>::new(0b000)}
        bop::BNE => {BitVector::<3>::new(0b001)}
        bop::BLT => {BitVector::<3>::new(0b100)}
        bop::BGE => {BitVector::<3>::new(0b101)}
        bop::BLTU => {BitVector::<3>::new(0b110)}
        bop::BGEU => {BitVector::<3>::new(0b111)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_bop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_bop_backwards(arg_hashtag_: BitVector<3>) -> bop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {bop::BEQ}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {bop::BNE}
        b__2 if {(b__2 == BitVector::<3>::new(0b100))} => {bop::BLT}
        b__3 if {(b__3 == BitVector::<3>::new(0b101))} => {bop::BGE}
        b__4 if {(b__4 == BitVector::<3>::new(0b110))} => {bop::BLTU}
        b__5 if {(b__5 == BitVector::<3>::new(0b111))} => {bop::BGEU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_bop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_bop_backwards_matches(arg_hashtag_: BitVector<3>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {true}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {true}
        b__2 if {(b__2 == BitVector::<3>::new(0b100))} => {true}
        b__3 if {(b__3 == BitVector::<3>::new(0b101))} => {true}
        b__4 if {(b__4 == BitVector::<3>::new(0b110))} => {true}
        b__5 if {(b__5 == BitVector::<3>::new(0b111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_iop_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_iop_forwards(arg_hashtag_: iop) -> BitVector<3> {
    match arg_hashtag_ {
        iop::ADDI => {BitVector::<3>::new(0b000)}
        iop::SLTI => {BitVector::<3>::new(0b010)}
        iop::SLTIU => {BitVector::<3>::new(0b011)}
        iop::ANDI => {BitVector::<3>::new(0b111)}
        iop::ORI => {BitVector::<3>::new(0b110)}
        iop::XORI => {BitVector::<3>::new(0b100)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_iop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_iop_backwards(arg_hashtag_: BitVector<3>) -> iop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {iop::ADDI}
        b__1 if {(b__1 == BitVector::<3>::new(0b010))} => {iop::SLTI}
        b__2 if {(b__2 == BitVector::<3>::new(0b011))} => {iop::SLTIU}
        b__3 if {(b__3 == BitVector::<3>::new(0b111))} => {iop::ANDI}
        b__4 if {(b__4 == BitVector::<3>::new(0b110))} => {iop::ORI}
        b__5 if {(b__5 == BitVector::<3>::new(0b100))} => {iop::XORI}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_iop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_iop_backwards_matches(arg_hashtag_: BitVector<3>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {true}
        b__1 if {(b__1 == BitVector::<3>::new(0b010))} => {true}
        b__2 if {(b__2 == BitVector::<3>::new(0b011))} => {true}
        b__3 if {(b__3 == BitVector::<3>::new(0b111))} => {true}
        b__4 if {(b__4 == BitVector::<3>::new(0b110))} => {true}
        b__5 if {(b__5 == BitVector::<3>::new(0b100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// valid_load_encdec
/// 
/// Generated from the Sail sources at `riscv_insts_base.sail` L279-280.
pub fn valid_load_encdec(width: word_width, is_unsigned: bool) -> bool {
    ((size_bytes_forwards(width) < 8) || (!(is_unsigned) && ((size_bytes_forwards(width) <= 8) as bool)))
}

/// effective_fence_set
/// 
/// Generated from the Sail sources at `riscv_insts_base.sail` L452-457.
pub fn effective_fence_set(set: BitVector<4>, fiom: bool) -> BitVector<4> {
    if {fiom} {
        bitvector_concat::<2, 2, 4>(set.subrange::<2, 4, 2>(), (set.subrange::<0, 2, 2>() | set.subrange::<2, 4, 2>()))
    } else {
        set
    }
}

/// lrsc_width_valid
/// 
/// Generated from the Sail sources at `riscv_insts_aext.sail` L31-37.
pub fn lrsc_width_valid(size: word_width) -> bool {
    match size {
        word_width::WORD => {true}
        word_width::DOUBLE => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// amo_width_valid
/// 
/// Generated from the Sail sources at `riscv_insts_aext.sail` L39-46.
pub fn amo_width_valid(core_ctx: &mut Core, size: word_width) -> bool {
    match size {
        word_width::BYTE => {currentlyEnabled(core_ctx, extension::Ext_Zabha)}
        word_width::HALF => {currentlyEnabled(core_ctx, extension::Ext_Zabha)}
        word_width::WORD => {true}
        word_width::DOUBLE => {true}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_amoop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_amoop_backwards(arg_hashtag_: BitVector<5>) -> amoop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00001))} => {amoop::AMOSWAP}
        b__1 if {(b__1 == BitVector::<5>::new(0b00000))} => {amoop::AMOADD}
        b__2 if {(b__2 == BitVector::<5>::new(0b00100))} => {amoop::AMOXOR}
        b__3 if {(b__3 == BitVector::<5>::new(0b01100))} => {amoop::AMOAND}
        b__4 if {(b__4 == BitVector::<5>::new(0b01000))} => {amoop::AMOOR}
        b__5 if {(b__5 == BitVector::<5>::new(0b10000))} => {amoop::AMOMIN}
        b__6 if {(b__6 == BitVector::<5>::new(0b10100))} => {amoop::AMOMAX}
        b__7 if {(b__7 == BitVector::<5>::new(0b11000))} => {amoop::AMOMINU}
        b__8 if {(b__8 == BitVector::<5>::new(0b11100))} => {amoop::AMOMAXU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_amoop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_amoop_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00001))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00000))} => {true}
        b__2 if {(b__2 == BitVector::<5>::new(0b00100))} => {true}
        b__3 if {(b__3 == BitVector::<5>::new(0b01100))} => {true}
        b__4 if {(b__4 == BitVector::<5>::new(0b01000))} => {true}
        b__5 if {(b__5 == BitVector::<5>::new(0b10000))} => {true}
        b__6 if {(b__6 == BitVector::<5>::new(0b10100))} => {true}
        b__7 if {(b__7 == BitVector::<5>::new(0b11000))} => {true}
        b__8 if {(b__8 == BitVector::<5>::new(0b11100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mul_op_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mul_op_forwards(arg_hashtag_: mul_op) -> BitVector<3> {
    match arg_hashtag_ {
        TODO_PAT_struct => {BitVector::<3>::new(0b000)}
        TODO_PAT_struct => {BitVector::<3>::new(0b001)}
        TODO_PAT_struct => {BitVector::<3>::new(0b010)}
        TODO_PAT_struct => {BitVector::<3>::new(0b011)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mul_op_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mul_op_backwards(arg_hashtag_: BitVector<3>) -> mul_op {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {mul_op {
            high: false,
            signed_rs1: true,
            signed_rs2: true
        }}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {mul_op {
            high: true,
            signed_rs1: true,
            signed_rs2: true
        }}
        b__2 if {(b__2 == BitVector::<3>::new(0b010))} => {mul_op {
            high: true,
            signed_rs1: true,
            signed_rs2: false
        }}
        b__3 if {(b__3 == BitVector::<3>::new(0b011))} => {mul_op {
            high: true,
            signed_rs1: false,
            signed_rs2: false
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mul_op_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mul_op_backwards_matches(arg_hashtag_: BitVector<3>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {true}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {true}
        b__2 if {(b__2 == BitVector::<3>::new(0b010))} => {true}
        b__3 if {(b__3 == BitVector::<3>::new(0b011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_csrop_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_csrop_forwards(arg_hashtag_: csrop) -> BitVector<2> {
    match arg_hashtag_ {
        csrop::CSRRW => {BitVector::<2>::new(0b01)}
        csrop::CSRRS => {BitVector::<2>::new(0b10)}
        csrop::CSRRC => {BitVector::<2>::new(0b11)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_csrop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_csrop_backwards(arg_hashtag_: BitVector<2>) -> csrop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b01))} => {csrop::CSRRW}
        b__1 if {(b__1 == BitVector::<2>::new(0b10))} => {csrop::CSRRS}
        b__2 if {(b__2 == BitVector::<2>::new(0b11))} => {csrop::CSRRC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_csrop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_csrop_backwards_matches(arg_hashtag_: BitVector<2>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b01))} => {true}
        b__1 if {(b__1 == BitVector::<2>::new(0b10))} => {true}
        b__2 if {(b__2 == BitVector::<2>::new(0b11))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// read_CSR
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L134.
pub fn read_CSR(core_ctx: &mut Core, merge_hashtag_var: BitVector<12>) -> BitVector<{
    64
}> {
    match merge_hashtag_var {
        b__0 if {(b__0 == BitVector::<12>::new(0b001100000001))} => {core_ctx.misa.bits}
        b__1 if {(b__1 == BitVector::<12>::new(0b001100000000))} => {core_ctx.mstatus.bits.subrange::<0, 64, 64>()}
        b__3 if {(b__3 == BitVector::<12>::new(0b001100001010))} => {core_ctx.menvcfg.bits.subrange::<0, 64, 64>()}
        b__5 if {(b__5 == BitVector::<12>::new(0b000100001010))} => {core_ctx.senvcfg.bits.subrange::<0, 64, 64>()}
        b__6 if {(b__6 == BitVector::<12>::new(0b001100000100))} => {core_ctx.mie.bits}
        b__7 if {(b__7 == BitVector::<12>::new(0b001101000100))} => {core_ctx.mip.bits}
        b__8 if {(b__8 == BitVector::<12>::new(0b001100000010))} => {core_ctx.medeleg.bits.subrange::<0, 64, 64>()}
        b__10 if {(b__10 == BitVector::<12>::new(0b001100000011))} => {core_ctx.mideleg.bits}
        b__11 if {(b__11 == BitVector::<12>::new(0b001101000010))} => {core_ctx.mcause.bits}
        b__12 if {(b__12 == BitVector::<12>::new(0b001101000011))} => {core_ctx.mtval}
        b__13 if {(b__13 == BitVector::<12>::new(0b001101000000))} => {core_ctx.mscratch}
        b__14 if {(b__14 == BitVector::<12>::new(0b000100000110))} => {core_ctx.scounteren.bits.zero_extend::<64>()}
        b__15 if {(b__15 == BitVector::<12>::new(0b001100000110))} => {core_ctx.mcounteren.bits.zero_extend::<64>()}
        b__16 if {(b__16 == BitVector::<12>::new(0b001100100000))} => {core_ctx.mcountinhibit.bits.zero_extend::<64>()}
        b__17 if {(b__17 == BitVector::<12>::new(0b111100010001))} => {core_ctx.mvendorid.zero_extend::<64>()}
        b__18 if {(b__18 == BitVector::<12>::new(0b111100010010))} => {core_ctx.marchid}
        b__19 if {(b__19 == BitVector::<12>::new(0b111100010011))} => {core_ctx.mimpid}
        b__20 if {(b__20 == BitVector::<12>::new(0b111100010100))} => {core_ctx.mhartid}
        b__21 if {(b__21 == BitVector::<12>::new(0b111100010101))} => {core_ctx.mconfigptr}
        b__22 if {(b__22 == BitVector::<12>::new(0b000100000000))} => {{
            let var_1 = core_ctx.mstatus;
            lower_mstatus(var_1)
        }.bits.subrange::<0, 64, 64>()}
        b__23 if {(b__23 == BitVector::<12>::new(0b000101000100))} => {{
            let var_2 = core_ctx.mip;
            let var_3 = core_ctx.mideleg;
            lower_mip(var_2, var_3)
        }.bits}
        b__24 if {(b__24 == BitVector::<12>::new(0b000100000100))} => {{
            let var_4 = core_ctx.mie;
            let var_5 = core_ctx.mideleg;
            lower_mie(var_4, var_5)
        }.bits}
        b__25 if {(b__25 == BitVector::<12>::new(0b000101000000))} => {core_ctx.sscratch}
        b__26 if {(b__26 == BitVector::<12>::new(0b000101000010))} => {core_ctx.scause.bits}
        b__27 if {(b__27 == BitVector::<12>::new(0b000101000011))} => {core_ctx.stval}
        b__28 if {(b__28 == BitVector::<12>::new(0b011110100000))} => {!(core_ctx.tselect)}
        v__3826 if {let idx_var_6: BitVector<4> = v__3826.subrange::<0, 4, 4>();
        ((v__3826.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111010)) && (bitvector_access(idx_var_6, 0) == false))} => {let idx: BitVector<4> = v__3826.subrange::<0, 4, 4>();
        pmpReadCfgReg(core_ctx, idx.unsigned())}
        v__3828 if {(v__3828.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111011))} => {let idx: BitVector<4> = v__3828.subrange::<0, 4, 4>();
        pmpReadAddrReg(core_ctx, bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b00), idx).unsigned())}
        v__3830 if {(v__3830.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111100))} => {let idx: BitVector<4> = v__3830.subrange::<0, 4, 4>();
        pmpReadAddrReg(core_ctx, bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b01), idx).unsigned())}
        v__3832 if {(v__3832.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111101))} => {let idx: BitVector<4> = v__3832.subrange::<0, 4, 4>();
        pmpReadAddrReg(core_ctx, bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b10), idx).unsigned())}
        v__3834 if {(v__3834.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111110))} => {let idx: BitVector<4> = v__3834.subrange::<0, 4, 4>();
        pmpReadAddrReg(core_ctx, bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b11), idx).unsigned())}
        b__29 if {(b__29 == BitVector::<12>::new(0b000000001000))} => {core_ctx.vstart.zero_extend::<64>()}
        b__30 if {(b__30 == BitVector::<12>::new(0b000000001001))} => {{
            let var_7 = core_ctx.vcsr;
            _get_Vcsr_vxsat(var_7)
        }.zero_extend::<64>()}
        b__31 if {(b__31 == BitVector::<12>::new(0b000000001010))} => {{
            let var_8 = core_ctx.vcsr;
            _get_Vcsr_vxrm(var_8)
        }.zero_extend::<64>()}
        b__32 if {(b__32 == BitVector::<12>::new(0b000000001111))} => {core_ctx.vcsr.bits.zero_extend::<64>()}
        b__33 if {(b__33 == BitVector::<12>::new(0b110000100000))} => {core_ctx.vl}
        b__34 if {(b__34 == BitVector::<12>::new(0b110000100001))} => {core_ctx.vtype.bits}
        b__35 if {(b__35 == BitVector::<12>::new(0b110000100010))} => {get_vlenb(())}
        b__36 if {(b__36 == BitVector::<12>::new(0b000100000101))} => {get_stvec(core_ctx, ())}
        b__37 if {(b__37 == BitVector::<12>::new(0b000101000001))} => {get_xepc(core_ctx, Privilege::Supervisor)}
        b__38 if {(b__38 == BitVector::<12>::new(0b001100000101))} => {get_mtvec(core_ctx, ())}
        b__39 if {(b__39 == BitVector::<12>::new(0b001101000001))} => {get_xepc(core_ctx, Privilege::Machine)}
        v__3836 if {let index_var_9: BitVector<5> = v__3836.subrange::<0, 5, 5>();
        ((v__3836.subrange::<5, 12, 7>() == BitVector::<7>::new(0b0011001)) && ((index_var_9.unsigned() >= 3) as bool))} => {let index: BitVector<5> = v__3836.subrange::<0, 5, 5>();
        read_mhpmevent(core_ctx, hpmidx_from_bits(index))}
        v__3838 if {let index_var_10: BitVector<5> = v__3838.subrange::<0, 5, 5>();
        ((v__3838.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1011000)) && ((index_var_10.unsigned() >= 3) as bool))} => {let index: BitVector<5> = v__3838.subrange::<0, 5, 5>();
        read_mhpmcounter(core_ctx, hpmidx_from_bits(index))}
        v__3842 if {let index_var_11: BitVector<5> = v__3842.subrange::<0, 5, 5>();
        ((v__3842.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1100000)) && ((index_var_11.unsigned() >= 3) as bool))} => {let index: BitVector<5> = v__3842.subrange::<0, 5, 5>();
        read_mhpmcounter(core_ctx, hpmidx_from_bits(index))}
        b__40 if {(b__40 == BitVector::<12>::new(0b110110100000))} => {{
            let var_12 = core_ctx.cur_privilege;
            get_scountovf(core_ctx, var_12)
        }.zero_extend::<64>()}
        b__41 if {(b__41 == BitVector::<12>::new(0b000000010101))} => {read_seed_csr(())}
        b__42 if {(b__42 == BitVector::<12>::new(0b110000000000))} => {subrange_bits::<_, 64>(core_ctx.mcycle, 63, 0)}
        b__43 if {(b__43 == BitVector::<12>::new(0b110000000001))} => {subrange_bits::<_, 64>(core_ctx.mtime, 63, 0)}
        b__44 if {(b__44 == BitVector::<12>::new(0b110000000010))} => {subrange_bits::<_, 64>(core_ctx.minstret, 63, 0)}
        b__48 if {(b__48 == BitVector::<12>::new(0b101100000000))} => {subrange_bits::<_, 64>(core_ctx.mcycle, 63, 0)}
        b__49 if {(b__49 == BitVector::<12>::new(0b101100000010))} => {subrange_bits::<_, 64>(core_ctx.minstret, 63, 0)}
        b__52 if {(b__52 == BitVector::<12>::new(0b000000000001))} => {{
            let var_13 = core_ctx.fcsr;
            _get_Fcsr_FFLAGS(var_13)
        }.zero_extend::<64>()}
        b__53 if {(b__53 == BitVector::<12>::new(0b000000000010))} => {{
            let var_14 = core_ctx.fcsr;
            _get_Fcsr_FRM(var_14)
        }.zero_extend::<64>()}
        b__54 if {(b__54 == BitVector::<12>::new(0b000000000011))} => {core_ctx.fcsr.bits.zero_extend::<64>()}
        b__55 if {(b__55 == BitVector::<12>::new(0b001100100001))} => {core_ctx.mcyclecfg.bits.subrange::<0, 64, 64>()}
        b__57 if {(b__57 == BitVector::<12>::new(0b001100100010))} => {core_ctx.minstretcfg.bits.subrange::<0, 64, 64>()}
        b__59 if {(b__59 == BitVector::<12>::new(0b000101001101))} => {subrange_bits::<_, 64>(core_ctx.stimecmp, 63, 0)}
        b__61 if {(b__61 == BitVector::<12>::new(0b000110000000))} => {core_ctx.satp}
        csr => {{
            panic!("{}, l {}: {}", "riscv_csr_end.sail", 17, format!("{}{}", "Read from CSR that does not exist: ", bits_str(csr)))
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// write_CSR
/// 
/// Generated from the Sail sources at `riscv_sys_regs.sail` L135.
pub fn write_CSR(core_ctx: &mut Core, merge_hashtag_var: BitVector<12>, missing_arg_0: BitVector<{
    64
}>) -> BitVector<{
    64
}> {
    match (merge_hashtag_var, missing_arg_0) {
        (b__0, value) if {(b__0 == BitVector::<12>::new(0b001100000001))} => {{
            core_ctx.misa = {
                let var_1 = core_ctx.misa;
                legalize_misa(core_ctx, var_1, value)
            };
            core_ctx.misa.bits
        }}
        (b__1, value) if {(b__1 == BitVector::<12>::new(0b001100000000))} => {{
            core_ctx.mstatus = {
                let var_2 = core_ctx.mstatus;
                legalize_mstatus(core_ctx, var_2, value)
            };
            core_ctx.mstatus.bits
        }}
        (b__5, value) if {(b__5 == BitVector::<12>::new(0b001100001010))} => {{
            core_ctx.menvcfg = {
                let var_3 = core_ctx.menvcfg;
                legalize_menvcfg(core_ctx, var_3, value)
            };
            core_ctx.menvcfg.bits
        }}
        (b__7, value) if {(b__7 == BitVector::<12>::new(0b000100001010))} => {{
            core_ctx.senvcfg = {
                let var_4 = core_ctx.senvcfg;
                legalize_senvcfg(core_ctx, var_4, value.zero_extend::<64>())
            };
            core_ctx.senvcfg.bits.subrange::<0, 64, 64>()
        }}
        (b__8, value) if {(b__8 == BitVector::<12>::new(0b001100000100))} => {{
            core_ctx.mie = {
                let var_5 = core_ctx.mie;
                legalize_mie(core_ctx, var_5, value)
            };
            core_ctx.mie.bits
        }}
        (b__9, value) if {(b__9 == BitVector::<12>::new(0b001101000100))} => {{
            core_ctx.mip = {
                let var_6 = core_ctx.mip;
                legalize_mip(core_ctx, var_6, value)
            };
            core_ctx.mip.bits
        }}
        (b__10, value) if {(b__10 == BitVector::<12>::new(0b001100000010))} => {{
            core_ctx.medeleg = {
                let var_7 = core_ctx.medeleg;
                legalize_medeleg(var_7, value)
            };
            core_ctx.medeleg.bits
        }}
        (b__13, value) if {(b__13 == BitVector::<12>::new(0b001100000011))} => {{
            core_ctx.mideleg = {
                let var_8 = core_ctx.mideleg;
                legalize_mideleg(var_8, value)
            };
            core_ctx.mideleg.bits
        }}
        (b__14, value) if {(b__14 == BitVector::<12>::new(0b001101000010))} => {{
            core_ctx.mcause.bits = value;
            core_ctx.mcause.bits
        }}
        (b__15, value) if {(b__15 == BitVector::<12>::new(0b001101000011))} => {{
            core_ctx.mtval = value;
            core_ctx.mtval
        }}
        (b__16, value) if {(b__16 == BitVector::<12>::new(0b001101000000))} => {{
            core_ctx.mscratch = value;
            core_ctx.mscratch
        }}
        (b__17, value) if {(b__17 == BitVector::<12>::new(0b000100000110))} => {{
            core_ctx.scounteren = {
                let var_9 = core_ctx.scounteren;
                legalize_scounteren(core_ctx, var_9, value)
            };
            core_ctx.scounteren.bits.zero_extend::<64>()
        }}
        (b__18, value) if {(b__18 == BitVector::<12>::new(0b001100000110))} => {{
            core_ctx.mcounteren = {
                let var_10 = core_ctx.mcounteren;
                legalize_mcounteren(core_ctx, var_10, value)
            };
            core_ctx.mcounteren.bits.zero_extend::<64>()
        }}
        (b__19, value) if {(b__19 == BitVector::<12>::new(0b001100100000))} => {{
            core_ctx.mcountinhibit = {
                let var_11 = core_ctx.mcountinhibit;
                legalize_mcountinhibit(core_ctx, var_11, value)
            };
            core_ctx.mcountinhibit.bits.zero_extend::<64>()
        }}
        (b__20, value) if {(b__20 == BitVector::<12>::new(0b000100000000))} => {{
            core_ctx.mstatus = {
                let var_12 = core_ctx.mstatus;
                legalize_sstatus(core_ctx, var_12, value)
            };
            core_ctx.mstatus.bits.subrange::<0, 64, 64>()
        }}
        (b__21, value) if {(b__21 == BitVector::<12>::new(0b000101000100))} => {{
            core_ctx.mip = {
                let var_13 = core_ctx.mip;
                let var_14 = core_ctx.mideleg;
                legalize_sip(var_13, var_14, value)
            };
            core_ctx.mip.bits
        }}
        (b__22, value) if {(b__22 == BitVector::<12>::new(0b000100000100))} => {{
            core_ctx.mie = {
                let var_15 = core_ctx.mie;
                let var_16 = core_ctx.mideleg;
                legalize_sie(var_15, var_16, value)
            };
            core_ctx.mie.bits
        }}
        (b__23, value) if {(b__23 == BitVector::<12>::new(0b000101000000))} => {{
            core_ctx.sscratch = value;
            core_ctx.sscratch
        }}
        (b__24, value) if {(b__24 == BitVector::<12>::new(0b000101000010))} => {{
            core_ctx.scause.bits = value;
            core_ctx.scause.bits
        }}
        (b__25, value) if {(b__25 == BitVector::<12>::new(0b000101000011))} => {{
            core_ctx.stval = value;
            core_ctx.stval
        }}
        (b__26, value) if {(b__26 == BitVector::<12>::new(0b011110100000))} => {{
            core_ctx.tselect = value;
            core_ctx.tselect
        }}
        (v__3848, value) if {let idx_var_17: BitVector<4> = v__3848.subrange::<0, 4, 4>();
        ((v__3848.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111010)) && (bitvector_access(idx_var_17, 0) == false))} => {let idx: BitVector<4> = v__3848.subrange::<0, 4, 4>();
        let idx = idx.unsigned();
        pmpWriteCfgReg(core_ctx, idx, value);
        pmpReadCfgReg(core_ctx, idx)}
        (v__3850, value) if {(v__3850.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111011))} => {let idx: BitVector<4> = v__3850.subrange::<0, 4, 4>();
        let idx = bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b00), idx).unsigned();
        pmpWriteAddrReg(core_ctx, idx, value);
        pmpReadAddrReg(core_ctx, idx)}
        (v__3852, value) if {(v__3852.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111100))} => {let idx: BitVector<4> = v__3852.subrange::<0, 4, 4>();
        let idx = bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b01), idx).unsigned();
        pmpWriteAddrReg(core_ctx, idx, value);
        pmpReadAddrReg(core_ctx, idx)}
        (v__3854, value) if {(v__3854.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111101))} => {let idx: BitVector<4> = v__3854.subrange::<0, 4, 4>();
        let idx = bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b10), idx).unsigned();
        pmpWriteAddrReg(core_ctx, idx, value);
        pmpReadAddrReg(core_ctx, idx)}
        (v__3856, value) if {(v__3856.subrange::<4, 12, 8>() == BitVector::<8>::new(0b00111110))} => {let idx: BitVector<4> = v__3856.subrange::<0, 4, 4>();
        let idx = bitvector_concat::<2, 4, 6>(BitVector::<2>::new(0b11), idx).unsigned();
        pmpWriteAddrReg(core_ctx, idx, value);
        pmpReadAddrReg(core_ctx, idx)}
        (b__27, value) if {(b__27 == BitVector::<12>::new(0b000000001000))} => {{
            set_vstart(core_ctx, value.subrange::<0, 16, 16>());
            core_ctx.vstart.zero_extend::<64>()
        }}
        (b__28, value) if {(b__28 == BitVector::<12>::new(0b000000001001))} => {{
            {
                let var_18 = {
                    let var_19 = core_ctx.vcsr;
                    _get_Vcsr_vxrm(var_19)
                };
                ext_write_vcsr(core_ctx, var_18, value.subrange::<0, 1, 1>())
            };
            {
                let var_20 = core_ctx.vcsr;
                _get_Vcsr_vxsat(var_20)
            }.zero_extend::<64>()
        }}
        (b__29, value) if {(b__29 == BitVector::<12>::new(0b000000001010))} => {{
            {
                let var_21 = {
                    let var_22 = core_ctx.vcsr;
                    _get_Vcsr_vxsat(var_22)
                };
                ext_write_vcsr(core_ctx, value.subrange::<0, 2, 2>(), var_21)
            };
            {
                let var_23 = core_ctx.vcsr;
                _get_Vcsr_vxrm(var_23)
            }.zero_extend::<64>()
        }}
        (b__30, value) if {(b__30 == BitVector::<12>::new(0b000000001111))} => {{
            ext_write_vcsr(core_ctx, value.subrange::<1, 3, 2>(), value.subrange::<0, 1, 1>());
            core_ctx.vcsr.bits.zero_extend::<64>()
        }}
        (b__31, value) if {(b__31 == BitVector::<12>::new(0b000100000101))} => {{
            set_stvec(core_ctx, value)
        }}
        (b__32, value) if {(b__32 == BitVector::<12>::new(0b000101000001))} => {{
            set_xepc(core_ctx, Privilege::Supervisor, value)
        }}
        (b__33, value) if {(b__33 == BitVector::<12>::new(0b001100000101))} => {{
            set_mtvec(core_ctx, value)
        }}
        (b__34, value) if {(b__34 == BitVector::<12>::new(0b001101000001))} => {{
            set_xepc(core_ctx, Privilege::Machine, value)
        }}
        (v__3858, value) if {let index_var_24: BitVector<5> = v__3858.subrange::<0, 5, 5>();
        ((v__3858.subrange::<5, 12, 7>() == BitVector::<7>::new(0b0011001)) && ((index_var_24.unsigned() >= 3) as bool))} => {let index: BitVector<5> = v__3858.subrange::<0, 5, 5>();
        let index = hpmidx_from_bits(index);
        write_mhpmevent(core_ctx, index, value);
        read_mhpmevent(core_ctx, index)}
        (v__3860, value) if {let index_var_25: BitVector<5> = v__3860.subrange::<0, 5, 5>();
        ((v__3860.subrange::<5, 12, 7>() == BitVector::<7>::new(0b1011000)) && ((index_var_25.unsigned() >= 3) as bool))} => {let index: BitVector<5> = v__3860.subrange::<0, 5, 5>();
        let index = hpmidx_from_bits(index);
        write_mhpmcounter(core_ctx, index, value);
        read_mhpmcounter(core_ctx, index)}
        (b__35, value) if {(b__35 == BitVector::<12>::new(0b000000010101))} => {write_seed_csr(())}
        (b__36, value) if {(b__36 == BitVector::<12>::new(0b101100000000))} => {{
            core_ctx.mcycle = core_ctx.mcycle.set_subrange::<0, 64, 64>(value);
            value
        }}
        (b__37, value) if {(b__37 == BitVector::<12>::new(0b101100000010))} => {{
            core_ctx.minstret = core_ctx.minstret.set_subrange::<0, 64, 64>(value);
            core_ctx.minstret_increment = false;
            value
        }}
        (b__40, value) if {(b__40 == BitVector::<12>::new(0b000000000001))} => {{
            {
                let var_26 = {
                    let var_27 = core_ctx.fcsr;
                    _get_Fcsr_FRM(var_27)
                };
                write_fcsr(core_ctx, var_26, value.subrange::<0, 5, 5>())
            };
            {
                let var_28 = core_ctx.fcsr;
                _get_Fcsr_FFLAGS(var_28)
            }.zero_extend::<64>()
        }}
        (b__41, value) if {(b__41 == BitVector::<12>::new(0b000000000010))} => {{
            {
                let var_29 = {
                    let var_30 = core_ctx.fcsr;
                    _get_Fcsr_FFLAGS(var_30)
                };
                write_fcsr(core_ctx, value.subrange::<0, 3, 3>(), var_29)
            };
            {
                let var_31 = core_ctx.fcsr;
                _get_Fcsr_FRM(var_31)
            }.zero_extend::<64>()
        }}
        (b__42, value) if {(b__42 == BitVector::<12>::new(0b000000000011))} => {{
            write_fcsr(core_ctx, value.subrange::<5, 8, 3>(), value.subrange::<0, 5, 5>());
            core_ctx.fcsr.bits.zero_extend::<64>()
        }}
        (b__43, value) if {(b__43 == BitVector::<12>::new(0b001100100001))} => {{
            core_ctx.mcyclecfg = {
                let var_32 = core_ctx.mcyclecfg;
                legalize_smcntrpmf(core_ctx, var_32, value)
            };
            core_ctx.mcyclecfg.bits
        }}
        (b__46, value) if {(b__46 == BitVector::<12>::new(0b001100100010))} => {{
            core_ctx.minstretcfg = {
                let var_33 = core_ctx.minstretcfg;
                legalize_smcntrpmf(core_ctx, var_33, value)
            };
            core_ctx.minstretcfg.bits.subrange::<0, 64, 64>()
        }}
        (b__49, value) if {(b__49 == BitVector::<12>::new(0b000101001101))} => {{
            core_ctx.stimecmp = core_ctx.stimecmp.set_subrange::<0, 64, 64>(value);
            subrange_bits::<_, 64>(core_ctx.stimecmp, 63, 0)
        }}
        (b__51, value) if {(b__51 == BitVector::<12>::new(0b000110000000))} => {{
            core_ctx.satp = {
                let var_34 = cur_architecture(core_ctx, ());
                let var_35 = core_ctx.satp;
                legalize_satp(core_ctx, var_34, var_35, value)
            };
            core_ctx.satp
        }}
        (csr, _) => {{
            panic!("{}, l {}: {}", "riscv_csr_end.sail", 23, format!("{}{}", "Write to CSR that does not exist: ", bits_str(csr)))
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// doCSR
/// 
/// Generated from the Sail sources at `riscv_insts_zicsr.sail` L27-50.
pub fn doCSR(core_ctx: &mut Core, csr: BitVector<12>, rs1_val: BitVector<{
    64
}>, rd: regidx, op: csrop, is_CSR_Write: bool) -> ExecutionResult {
    if {!({
        let var_1 = core_ctx.cur_privilege;
        check_CSR(core_ctx, csr, var_1, is_CSR_Write)
    })} {
        ExecutionResult::Illegal_Instruction(())
    } else if {!(true)} {
        ExecutionResult::Ext_CSR_Check_Failure(())
    } else {
        let is_CSR_Read = !(((op == csrop::CSRRW) && (rd == zreg)));
        let csr_val: xlenbits = if {is_CSR_Read} {
            read_CSR(core_ctx, csr)
        } else {
            zeros::<64>(64)
        };
        if {is_CSR_Write} {
            let new_val: xlenbits = match op {
                csrop::CSRRW => {rs1_val}
                csrop::CSRRS => {(csr_val | rs1_val)}
                csrop::CSRRC => {(csr_val & !(rs1_val))}
                _ => {panic!("Unreachable code")}
            };
            let final_val = write_CSR(core_ctx, csr, new_val);
            
        } else {
            csr_id_read_callback(csr, csr_val)
        };
        wX_bits(core_ctx, rd, csr_val);
        RETIRE_SUCCESS
    }
}

/// encdec_rounding_mode_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_rounding_mode_backwards(arg_hashtag_: BitVector<3>) -> rounding_mode {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {rounding_mode::RM_RNE}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {rounding_mode::RM_RTZ}
        b__2 if {(b__2 == BitVector::<3>::new(0b010))} => {rounding_mode::RM_RDN}
        b__3 if {(b__3 == BitVector::<3>::new(0b011))} => {rounding_mode::RM_RUP}
        b__4 if {(b__4 == BitVector::<3>::new(0b100))} => {rounding_mode::RM_RMM}
        b__5 if {(b__5 == BitVector::<3>::new(0b111))} => {rounding_mode::RM_DYN}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rounding_mode_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_rounding_mode_backwards_matches(arg_hashtag_: BitVector<3>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {true}
        b__1 if {(b__1 == BitVector::<3>::new(0b001))} => {true}
        b__2 if {(b__2 == BitVector::<3>::new(0b010))} => {true}
        b__3 if {(b__3 == BitVector::<3>::new(0b011))} => {true}
        b__4 if {(b__4 == BitVector::<3>::new(0b100))} => {true}
        b__5 if {(b__5 == BitVector::<3>::new(0b111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// haveSingleFPU
/// 
/// Generated from the Sail sources at `riscv_insts_fext.sail` L265.
pub fn haveSingleFPU(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (currentlyEnabled(core_ctx, extension::Ext_F) || currentlyEnabled(core_ctx, extension::Ext_Zfinx))
}

/// haveDoubleFPU
/// 
/// Generated from the Sail sources at `riscv_insts_dext.sail` L229.
pub fn haveDoubleFPU(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (currentlyEnabled(core_ctx, extension::Ext_D) || currentlyEnabled(core_ctx, extension::Ext_Zdinx))
}

/// validDoubleRegs
/// 
/// Generated from the Sail sources at `riscv_insts_dext.sail` L234-241.
pub fn validDoubleRegs<const N: usize>(core_ctx: &mut Core, n: i128, regs: [fregidx; N]) -> bool {
    true
}

/// haveHalfFPU
/// 
/// Generated from the Sail sources at `riscv_insts_zfh.sail` L167.
pub fn haveHalfFPU(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (currentlyEnabled(core_ctx, extension::Ext_Zfh) || currentlyEnabled(core_ctx, extension::Ext_Zhinx))
}

/// haveHalfMin
/// 
/// Generated from the Sail sources at `riscv_insts_zfh.sail` L170.
pub fn haveHalfMin(core_ctx: &mut Core, unit_arg: ()) -> bool {
    (haveHalfFPU(core_ctx, ()) || currentlyEnabled(core_ctx, extension::Ext_Zfhmin))
}

pub type nfields = i128;

/// encdec_vvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vvfunct6_backwards(arg_hashtag_: BitVector<6>) -> vvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {vvfunct6::VV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {vvfunct6::VV_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {vvfunct6::VV_VMINU}
        b__3 if {(b__3 == BitVector::<6>::new(0b000101))} => {vvfunct6::VV_VMIN}
        b__4 if {(b__4 == BitVector::<6>::new(0b000110))} => {vvfunct6::VV_VMAXU}
        b__5 if {(b__5 == BitVector::<6>::new(0b000111))} => {vvfunct6::VV_VMAX}
        b__6 if {(b__6 == BitVector::<6>::new(0b001001))} => {vvfunct6::VV_VAND}
        b__7 if {(b__7 == BitVector::<6>::new(0b001010))} => {vvfunct6::VV_VOR}
        b__8 if {(b__8 == BitVector::<6>::new(0b001011))} => {vvfunct6::VV_VXOR}
        b__9 if {(b__9 == BitVector::<6>::new(0b001100))} => {vvfunct6::VV_VRGATHER}
        b__10 if {(b__10 == BitVector::<6>::new(0b001110))} => {vvfunct6::VV_VRGATHEREI16}
        b__11 if {(b__11 == BitVector::<6>::new(0b100000))} => {vvfunct6::VV_VSADDU}
        b__12 if {(b__12 == BitVector::<6>::new(0b100001))} => {vvfunct6::VV_VSADD}
        b__13 if {(b__13 == BitVector::<6>::new(0b100010))} => {vvfunct6::VV_VSSUBU}
        b__14 if {(b__14 == BitVector::<6>::new(0b100011))} => {vvfunct6::VV_VSSUB}
        b__15 if {(b__15 == BitVector::<6>::new(0b100101))} => {vvfunct6::VV_VSLL}
        b__16 if {(b__16 == BitVector::<6>::new(0b100111))} => {vvfunct6::VV_VSMUL}
        b__17 if {(b__17 == BitVector::<6>::new(0b101000))} => {vvfunct6::VV_VSRL}
        b__18 if {(b__18 == BitVector::<6>::new(0b101001))} => {vvfunct6::VV_VSRA}
        b__19 if {(b__19 == BitVector::<6>::new(0b101010))} => {vvfunct6::VV_VSSRL}
        b__20 if {(b__20 == BitVector::<6>::new(0b101011))} => {vvfunct6::VV_VSSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000101))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b000110))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b000111))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b001001))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b001010))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b001011))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b001100))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b001110))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b100000))} => {true}
        b__12 if {(b__12 == BitVector::<6>::new(0b100001))} => {true}
        b__13 if {(b__13 == BitVector::<6>::new(0b100010))} => {true}
        b__14 if {(b__14 == BitVector::<6>::new(0b100011))} => {true}
        b__15 if {(b__15 == BitVector::<6>::new(0b100101))} => {true}
        b__16 if {(b__16 == BitVector::<6>::new(0b100111))} => {true}
        b__17 if {(b__17 == BitVector::<6>::new(0b101000))} => {true}
        b__18 if {(b__18 == BitVector::<6>::new(0b101001))} => {true}
        b__19 if {(b__19 == BitVector::<6>::new(0b101010))} => {true}
        b__20 if {(b__20 == BitVector::<6>::new(0b101011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nvsfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nvsfunct6_backwards(arg_hashtag_: BitVector<6>) -> nvsfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {nvsfunct6::NVS_VNSRL}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {nvsfunct6::NVS_VNSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nvsfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nvsfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nvfunct6_backwards(arg_hashtag_: BitVector<6>) -> nvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {nvfunct6::NV_VNCLIPU}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {nvfunct6::NV_VNCLIP}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {vxfunct6::VX_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {vxfunct6::VX_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b000011))} => {vxfunct6::VX_VRSUB}
        b__3 if {(b__3 == BitVector::<6>::new(0b000100))} => {vxfunct6::VX_VMINU}
        b__4 if {(b__4 == BitVector::<6>::new(0b000101))} => {vxfunct6::VX_VMIN}
        b__5 if {(b__5 == BitVector::<6>::new(0b000110))} => {vxfunct6::VX_VMAXU}
        b__6 if {(b__6 == BitVector::<6>::new(0b000111))} => {vxfunct6::VX_VMAX}
        b__7 if {(b__7 == BitVector::<6>::new(0b001001))} => {vxfunct6::VX_VAND}
        b__8 if {(b__8 == BitVector::<6>::new(0b001010))} => {vxfunct6::VX_VOR}
        b__9 if {(b__9 == BitVector::<6>::new(0b001011))} => {vxfunct6::VX_VXOR}
        b__10 if {(b__10 == BitVector::<6>::new(0b100000))} => {vxfunct6::VX_VSADDU}
        b__11 if {(b__11 == BitVector::<6>::new(0b100001))} => {vxfunct6::VX_VSADD}
        b__12 if {(b__12 == BitVector::<6>::new(0b100010))} => {vxfunct6::VX_VSSUBU}
        b__13 if {(b__13 == BitVector::<6>::new(0b100011))} => {vxfunct6::VX_VSSUB}
        b__14 if {(b__14 == BitVector::<6>::new(0b100101))} => {vxfunct6::VX_VSLL}
        b__15 if {(b__15 == BitVector::<6>::new(0b100111))} => {vxfunct6::VX_VSMUL}
        b__16 if {(b__16 == BitVector::<6>::new(0b101000))} => {vxfunct6::VX_VSRL}
        b__17 if {(b__17 == BitVector::<6>::new(0b101001))} => {vxfunct6::VX_VSRA}
        b__18 if {(b__18 == BitVector::<6>::new(0b101010))} => {vxfunct6::VX_VSSRL}
        b__19 if {(b__19 == BitVector::<6>::new(0b101011))} => {vxfunct6::VX_VSSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000011))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000100))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b000101))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b000110))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b000111))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b001001))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b001010))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b001011))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b100000))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b100001))} => {true}
        b__12 if {(b__12 == BitVector::<6>::new(0b100010))} => {true}
        b__13 if {(b__13 == BitVector::<6>::new(0b100011))} => {true}
        b__14 if {(b__14 == BitVector::<6>::new(0b100101))} => {true}
        b__15 if {(b__15 == BitVector::<6>::new(0b100111))} => {true}
        b__16 if {(b__16 == BitVector::<6>::new(0b101000))} => {true}
        b__17 if {(b__17 == BitVector::<6>::new(0b101001))} => {true}
        b__18 if {(b__18 == BitVector::<6>::new(0b101010))} => {true}
        b__19 if {(b__19 == BitVector::<6>::new(0b101011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nxsfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nxsfunct6_backwards(arg_hashtag_: BitVector<6>) -> nxsfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {nxsfunct6::NXS_VNSRL}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {nxsfunct6::NXS_VNSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nxsfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nxsfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nxfunct6_backwards(arg_hashtag_: BitVector<6>) -> nxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {nxfunct6::NX_VNCLIPU}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {nxfunct6::NX_VNCLIP}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxsgfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxsgfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxsgfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001110))} => {vxsgfunct6::VX_VSLIDEUP}
        b__1 if {(b__1 == BitVector::<6>::new(0b001111))} => {vxsgfunct6::VX_VSLIDEDOWN}
        b__2 if {(b__2 == BitVector::<6>::new(0b001100))} => {vxsgfunct6::VX_VRGATHER}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxsgfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxsgfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b001111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b001100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vifunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vifunct6_backwards(arg_hashtag_: BitVector<6>) -> vifunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {vifunct6::VI_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b000011))} => {vifunct6::VI_VRSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b001001))} => {vifunct6::VI_VAND}
        b__3 if {(b__3 == BitVector::<6>::new(0b001010))} => {vifunct6::VI_VOR}
        b__4 if {(b__4 == BitVector::<6>::new(0b001011))} => {vifunct6::VI_VXOR}
        b__5 if {(b__5 == BitVector::<6>::new(0b100000))} => {vifunct6::VI_VSADDU}
        b__6 if {(b__6 == BitVector::<6>::new(0b100001))} => {vifunct6::VI_VSADD}
        b__7 if {(b__7 == BitVector::<6>::new(0b100101))} => {vifunct6::VI_VSLL}
        b__8 if {(b__8 == BitVector::<6>::new(0b101000))} => {vifunct6::VI_VSRL}
        b__9 if {(b__9 == BitVector::<6>::new(0b101001))} => {vifunct6::VI_VSRA}
        b__10 if {(b__10 == BitVector::<6>::new(0b101010))} => {vifunct6::VI_VSSRL}
        b__11 if {(b__11 == BitVector::<6>::new(0b101011))} => {vifunct6::VI_VSSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vifunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vifunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000011))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b001001))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b001010))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b001011))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b100000))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b100001))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b100101))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b101000))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b101001))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b101010))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b101011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nisfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nisfunct6_backwards(arg_hashtag_: BitVector<6>) -> nisfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {nisfunct6::NIS_VNSRL}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {nisfunct6::NIS_VNSRA}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nisfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nisfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101101))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nifunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_nifunct6_backwards(arg_hashtag_: BitVector<6>) -> nifunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {nifunct6::NI_VNCLIPU}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {nifunct6::NI_VNCLIP}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_nifunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_nifunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_visgfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_visgfunct6_backwards(arg_hashtag_: BitVector<6>) -> visgfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001110))} => {visgfunct6::VI_VSLIDEUP}
        b__1 if {(b__1 == BitVector::<6>::new(0b001111))} => {visgfunct6::VI_VSLIDEDOWN}
        b__2 if {(b__2 == BitVector::<6>::new(0b001100))} => {visgfunct6::VI_VRGATHER}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_visgfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_visgfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b001111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b001100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> mvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001000))} => {mvvfunct6::MVV_VAADDU}
        b__1 if {(b__1 == BitVector::<6>::new(0b001001))} => {mvvfunct6::MVV_VAADD}
        b__2 if {(b__2 == BitVector::<6>::new(0b001010))} => {mvvfunct6::MVV_VASUBU}
        b__3 if {(b__3 == BitVector::<6>::new(0b001011))} => {mvvfunct6::MVV_VASUB}
        b__4 if {(b__4 == BitVector::<6>::new(0b100101))} => {mvvfunct6::MVV_VMUL}
        b__5 if {(b__5 == BitVector::<6>::new(0b100111))} => {mvvfunct6::MVV_VMULH}
        b__6 if {(b__6 == BitVector::<6>::new(0b100100))} => {mvvfunct6::MVV_VMULHU}
        b__7 if {(b__7 == BitVector::<6>::new(0b100110))} => {mvvfunct6::MVV_VMULHSU}
        b__8 if {(b__8 == BitVector::<6>::new(0b100000))} => {mvvfunct6::MVV_VDIVU}
        b__9 if {(b__9 == BitVector::<6>::new(0b100001))} => {mvvfunct6::MVV_VDIV}
        b__10 if {(b__10 == BitVector::<6>::new(0b100010))} => {mvvfunct6::MVV_VREMU}
        b__11 if {(b__11 == BitVector::<6>::new(0b100011))} => {mvvfunct6::MVV_VREM}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b001001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b001010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b001011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b100101))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b100111))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b100100))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b100110))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b100000))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b100001))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b100010))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b100011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvvmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mvvmafunct6_backwards(arg_hashtag_: BitVector<6>) -> mvvmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101101))} => {mvvmafunct6::MVV_VMACC}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {mvvmafunct6::MVV_VNMSAC}
        b__2 if {(b__2 == BitVector::<6>::new(0b101001))} => {mvvmafunct6::MVV_VMADD}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {mvvmafunct6::MVV_VNMSUB}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvvmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mvvmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101101))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b101001))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> wvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110001))} => {wvvfunct6::WVV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110011))} => {wvvfunct6::WVV_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b110000))} => {wvvfunct6::WVV_VADDU}
        b__3 if {(b__3 == BitVector::<6>::new(0b110010))} => {wvvfunct6::WVV_VSUBU}
        b__4 if {(b__4 == BitVector::<6>::new(0b111011))} => {wvvfunct6::WVV_VWMUL}
        b__5 if {(b__5 == BitVector::<6>::new(0b111000))} => {wvvfunct6::WVV_VWMULU}
        b__6 if {(b__6 == BitVector::<6>::new(0b111010))} => {wvvfunct6::WVV_VWMULSU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110011))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b110000))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b110010))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b111011))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b111000))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b111010))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wvfunct6_backwards(arg_hashtag_: BitVector<6>) -> wvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110101))} => {wvfunct6::WV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110111))} => {wvfunct6::WV_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b110100))} => {wvfunct6::WV_VADDU}
        b__3 if {(b__3 == BitVector::<6>::new(0b110110))} => {wvfunct6::WV_VSUBU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110101))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b110100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b110110))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wmvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wmvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> wmvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {wmvvfunct6::WMVV_VWMACCU}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {wmvvfunct6::WMVV_VWMACC}
        b__2 if {(b__2 == BitVector::<6>::new(0b111111))} => {wmvvfunct6::WMVV_VWMACCSU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wmvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wmvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// vext2_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn vext2_vs1_backwards(arg_hashtag_: BitVector<5>) -> vext2funct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00110))} => {vext2funct6::VEXT2_ZVF2}
        b__1 if {(b__1 == BitVector::<5>::new(0b00111))} => {vext2funct6::VEXT2_SVF2}
        _ => {panic!("Unreachable code")}
    }
}

/// vext2_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn vext2_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00110))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// vext4_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn vext4_vs1_backwards(arg_hashtag_: BitVector<5>) -> vext4funct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00100))} => {vext4funct6::VEXT4_ZVF4}
        b__1 if {(b__1 == BitVector::<5>::new(0b00101))} => {vext4funct6::VEXT4_SVF4}
        _ => {panic!("Unreachable code")}
    }
}

/// vext4_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn vext4_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00100))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00101))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// vext8_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn vext8_vs1_backwards(arg_hashtag_: BitVector<5>) -> vext8funct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00010))} => {vext8funct6::VEXT8_ZVF8}
        b__1 if {(b__1 == BitVector::<5>::new(0b00011))} => {vext8funct6::VEXT8_SVF8}
        _ => {panic!("Unreachable code")}
    }
}

/// vext8_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn vext8_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00010))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mvxfunct6_backwards(arg_hashtag_: BitVector<6>) -> mvxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001000))} => {mvxfunct6::MVX_VAADDU}
        b__1 if {(b__1 == BitVector::<6>::new(0b001001))} => {mvxfunct6::MVX_VAADD}
        b__2 if {(b__2 == BitVector::<6>::new(0b001010))} => {mvxfunct6::MVX_VASUBU}
        b__3 if {(b__3 == BitVector::<6>::new(0b001011))} => {mvxfunct6::MVX_VASUB}
        b__4 if {(b__4 == BitVector::<6>::new(0b001110))} => {mvxfunct6::MVX_VSLIDE1UP}
        b__5 if {(b__5 == BitVector::<6>::new(0b001111))} => {mvxfunct6::MVX_VSLIDE1DOWN}
        b__6 if {(b__6 == BitVector::<6>::new(0b100101))} => {mvxfunct6::MVX_VMUL}
        b__7 if {(b__7 == BitVector::<6>::new(0b100111))} => {mvxfunct6::MVX_VMULH}
        b__8 if {(b__8 == BitVector::<6>::new(0b100100))} => {mvxfunct6::MVX_VMULHU}
        b__9 if {(b__9 == BitVector::<6>::new(0b100110))} => {mvxfunct6::MVX_VMULHSU}
        b__10 if {(b__10 == BitVector::<6>::new(0b100000))} => {mvxfunct6::MVX_VDIVU}
        b__11 if {(b__11 == BitVector::<6>::new(0b100001))} => {mvxfunct6::MVX_VDIV}
        b__12 if {(b__12 == BitVector::<6>::new(0b100010))} => {mvxfunct6::MVX_VREMU}
        b__13 if {(b__13 == BitVector::<6>::new(0b100011))} => {mvxfunct6::MVX_VREM}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mvxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b001000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b001001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b001010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b001011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b001110))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b001111))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b100101))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b100111))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b100100))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b100110))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b100000))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b100001))} => {true}
        b__12 if {(b__12 == BitVector::<6>::new(0b100010))} => {true}
        b__13 if {(b__13 == BitVector::<6>::new(0b100011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvxmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mvxmafunct6_backwards(arg_hashtag_: BitVector<6>) -> mvxmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101101))} => {mvxmafunct6::MVX_VMACC}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {mvxmafunct6::MVX_VNMSAC}
        b__2 if {(b__2 == BitVector::<6>::new(0b101001))} => {mvxmafunct6::MVX_VMADD}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {mvxmafunct6::MVX_VNMSUB}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mvxmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mvxmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101101))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b101001))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wvxfunct6_backwards(arg_hashtag_: BitVector<6>) -> wvxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110001))} => {wvxfunct6::WVX_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110011))} => {wvxfunct6::WVX_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b110000))} => {wvxfunct6::WVX_VADDU}
        b__3 if {(b__3 == BitVector::<6>::new(0b110010))} => {wvxfunct6::WVX_VSUBU}
        b__4 if {(b__4 == BitVector::<6>::new(0b111011))} => {wvxfunct6::WVX_VWMUL}
        b__5 if {(b__5 == BitVector::<6>::new(0b111000))} => {wvxfunct6::WVX_VWMULU}
        b__6 if {(b__6 == BitVector::<6>::new(0b111010))} => {wvxfunct6::WVX_VWMULSU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wvxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wvxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110011))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b110000))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b110010))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b111011))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b111000))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b111010))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wxfunct6_backwards(arg_hashtag_: BitVector<6>) -> wxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110101))} => {wxfunct6::WX_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110111))} => {wxfunct6::WX_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b110100))} => {wxfunct6::WX_VADDU}
        b__3 if {(b__3 == BitVector::<6>::new(0b110110))} => {wxfunct6::WX_VSUBU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110101))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110111))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b110100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b110110))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wmvxfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_wmvxfunct6_backwards(arg_hashtag_: BitVector<6>) -> wmvxfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {wmvxfunct6::WMVX_VWMACCU}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {wmvxfunct6::WMVX_VWMACC}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {wmvxfunct6::WMVX_VWMACCUS}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {wmvxfunct6::WMVX_VWMACCSU}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_wmvxfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_wmvxfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> fvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {fvvfunct6::FVV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {fvvfunct6::FVV_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {fvvfunct6::FVV_VMIN}
        b__3 if {(b__3 == BitVector::<6>::new(0b000110))} => {fvvfunct6::FVV_VMAX}
        b__4 if {(b__4 == BitVector::<6>::new(0b001000))} => {fvvfunct6::FVV_VSGNJ}
        b__5 if {(b__5 == BitVector::<6>::new(0b001001))} => {fvvfunct6::FVV_VSGNJN}
        b__6 if {(b__6 == BitVector::<6>::new(0b001010))} => {fvvfunct6::FVV_VSGNJX}
        b__7 if {(b__7 == BitVector::<6>::new(0b100000))} => {fvvfunct6::FVV_VDIV}
        b__8 if {(b__8 == BitVector::<6>::new(0b100100))} => {fvvfunct6::FVV_VMUL}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000110))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b001000))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b001001))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b001010))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b100000))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b100100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvmafunct6_backwards(arg_hashtag_: BitVector<6>) -> fvvmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101000))} => {fvvmafunct6::FVV_VMADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b101001))} => {fvvmafunct6::FVV_VNMADD}
        b__2 if {(b__2 == BitVector::<6>::new(0b101010))} => {fvvmafunct6::FVV_VMSUB}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {fvvmafunct6::FVV_VNMSUB}
        b__4 if {(b__4 == BitVector::<6>::new(0b101100))} => {fvvmafunct6::FVV_VMACC}
        b__5 if {(b__5 == BitVector::<6>::new(0b101101))} => {fvvmafunct6::FVV_VNMACC}
        b__6 if {(b__6 == BitVector::<6>::new(0b101110))} => {fvvmafunct6::FVV_VMSAC}
        b__7 if {(b__7 == BitVector::<6>::new(0b101111))} => {fvvmafunct6::FVV_VNMSAC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b101010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b101100))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b101101))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b101110))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> fwvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {fwvvfunct6::FWVV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110010))} => {fwvvfunct6::FWVV_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b111000))} => {fwvvfunct6::FWVV_VMUL}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111000))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvvmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvvmafunct6_backwards(arg_hashtag_: BitVector<6>) -> fwvvmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {fwvvmafunct6::FWVV_VMACC}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {fwvvmafunct6::FWVV_VNMACC}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {fwvvmafunct6::FWVV_VMSAC}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {fwvvmafunct6::FWVV_VNMSAC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvvmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvvmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvfunct6_backwards(arg_hashtag_: BitVector<6>) -> fwvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110100))} => {fwvfunct6::FWV_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110110))} => {fwvfunct6::FWV_VSUB}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110110))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfunary0_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vfunary0_vs1_backwards(arg_hashtag_: BitVector<5>) -> vfunary0 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00000))} => {vfunary0::FV_CVT_XU_F}
        b__1 if {(b__1 == BitVector::<5>::new(0b00001))} => {vfunary0::FV_CVT_X_F}
        b__2 if {(b__2 == BitVector::<5>::new(0b00010))} => {vfunary0::FV_CVT_F_XU}
        b__3 if {(b__3 == BitVector::<5>::new(0b00011))} => {vfunary0::FV_CVT_F_X}
        b__4 if {(b__4 == BitVector::<5>::new(0b00110))} => {vfunary0::FV_CVT_RTZ_XU_F}
        b__5 if {(b__5 == BitVector::<5>::new(0b00111))} => {vfunary0::FV_CVT_RTZ_X_F}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfunary0_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vfunary0_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00000))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00001))} => {true}
        b__2 if {(b__2 == BitVector::<5>::new(0b00010))} => {true}
        b__3 if {(b__3 == BitVector::<5>::new(0b00011))} => {true}
        b__4 if {(b__4 == BitVector::<5>::new(0b00110))} => {true}
        b__5 if {(b__5 == BitVector::<5>::new(0b00111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfwunary0_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vfwunary0_vs1_backwards(arg_hashtag_: BitVector<5>) -> vfwunary0 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b01000))} => {vfwunary0::FWV_CVT_XU_F}
        b__1 if {(b__1 == BitVector::<5>::new(0b01001))} => {vfwunary0::FWV_CVT_X_F}
        b__2 if {(b__2 == BitVector::<5>::new(0b01010))} => {vfwunary0::FWV_CVT_F_XU}
        b__3 if {(b__3 == BitVector::<5>::new(0b01011))} => {vfwunary0::FWV_CVT_F_X}
        b__4 if {(b__4 == BitVector::<5>::new(0b01100))} => {vfwunary0::FWV_CVT_F_F}
        b__5 if {(b__5 == BitVector::<5>::new(0b01110))} => {vfwunary0::FWV_CVT_RTZ_XU_F}
        b__6 if {(b__6 == BitVector::<5>::new(0b01111))} => {vfwunary0::FWV_CVT_RTZ_X_F}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfwunary0_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vfwunary0_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b01000))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b01001))} => {true}
        b__2 if {(b__2 == BitVector::<5>::new(0b01010))} => {true}
        b__3 if {(b__3 == BitVector::<5>::new(0b01011))} => {true}
        b__4 if {(b__4 == BitVector::<5>::new(0b01100))} => {true}
        b__5 if {(b__5 == BitVector::<5>::new(0b01110))} => {true}
        b__6 if {(b__6 == BitVector::<5>::new(0b01111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfnunary0_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vfnunary0_vs1_backwards(arg_hashtag_: BitVector<5>) -> vfnunary0 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b10000))} => {vfnunary0::FNV_CVT_XU_F}
        b__1 if {(b__1 == BitVector::<5>::new(0b10001))} => {vfnunary0::FNV_CVT_X_F}
        b__2 if {(b__2 == BitVector::<5>::new(0b10010))} => {vfnunary0::FNV_CVT_F_XU}
        b__3 if {(b__3 == BitVector::<5>::new(0b10011))} => {vfnunary0::FNV_CVT_F_X}
        b__4 if {(b__4 == BitVector::<5>::new(0b10100))} => {vfnunary0::FNV_CVT_F_F}
        b__5 if {(b__5 == BitVector::<5>::new(0b10101))} => {vfnunary0::FNV_CVT_ROD_F_F}
        b__6 if {(b__6 == BitVector::<5>::new(0b10110))} => {vfnunary0::FNV_CVT_RTZ_XU_F}
        b__7 if {(b__7 == BitVector::<5>::new(0b10111))} => {vfnunary0::FNV_CVT_RTZ_X_F}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfnunary0_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vfnunary0_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b10000))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b10001))} => {true}
        b__2 if {(b__2 == BitVector::<5>::new(0b10010))} => {true}
        b__3 if {(b__3 == BitVector::<5>::new(0b10011))} => {true}
        b__4 if {(b__4 == BitVector::<5>::new(0b10100))} => {true}
        b__5 if {(b__5 == BitVector::<5>::new(0b10101))} => {true}
        b__6 if {(b__6 == BitVector::<5>::new(0b10110))} => {true}
        b__7 if {(b__7 == BitVector::<5>::new(0b10111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfunary1_vs1_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vfunary1_vs1_backwards(arg_hashtag_: BitVector<5>) -> vfunary1 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00000))} => {vfunary1::FVV_VSQRT}
        b__1 if {(b__1 == BitVector::<5>::new(0b00100))} => {vfunary1::FVV_VRSQRT7}
        b__2 if {(b__2 == BitVector::<5>::new(0b00101))} => {vfunary1::FVV_VREC7}
        b__3 if {(b__3 == BitVector::<5>::new(0b10000))} => {vfunary1::FVV_VCLASS}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vfunary1_vs1_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vfunary1_vs1_backwards_matches(arg_hashtag_: BitVector<5>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<5>::new(0b00000))} => {true}
        b__1 if {(b__1 == BitVector::<5>::new(0b00100))} => {true}
        b__2 if {(b__2 == BitVector::<5>::new(0b00101))} => {true}
        b__3 if {(b__3 == BitVector::<5>::new(0b10000))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvffunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvffunct6_backwards(arg_hashtag_: BitVector<6>) -> fvffunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {fvffunct6::VF_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {fvffunct6::VF_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {fvffunct6::VF_VMIN}
        b__3 if {(b__3 == BitVector::<6>::new(0b000110))} => {fvffunct6::VF_VMAX}
        b__4 if {(b__4 == BitVector::<6>::new(0b001000))} => {fvffunct6::VF_VSGNJ}
        b__5 if {(b__5 == BitVector::<6>::new(0b001001))} => {fvffunct6::VF_VSGNJN}
        b__6 if {(b__6 == BitVector::<6>::new(0b001010))} => {fvffunct6::VF_VSGNJX}
        b__7 if {(b__7 == BitVector::<6>::new(0b001110))} => {fvffunct6::VF_VSLIDE1UP}
        b__8 if {(b__8 == BitVector::<6>::new(0b001111))} => {fvffunct6::VF_VSLIDE1DOWN}
        b__9 if {(b__9 == BitVector::<6>::new(0b100000))} => {fvffunct6::VF_VDIV}
        b__10 if {(b__10 == BitVector::<6>::new(0b100001))} => {fvffunct6::VF_VRDIV}
        b__11 if {(b__11 == BitVector::<6>::new(0b100100))} => {fvffunct6::VF_VMUL}
        b__12 if {(b__12 == BitVector::<6>::new(0b100111))} => {fvffunct6::VF_VRSUB}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvffunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvffunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000110))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b001000))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b001001))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b001010))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b001110))} => {true}
        b__8 if {(b__8 == BitVector::<6>::new(0b001111))} => {true}
        b__9 if {(b__9 == BitVector::<6>::new(0b100000))} => {true}
        b__10 if {(b__10 == BitVector::<6>::new(0b100001))} => {true}
        b__11 if {(b__11 == BitVector::<6>::new(0b100100))} => {true}
        b__12 if {(b__12 == BitVector::<6>::new(0b100111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvfmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvfmafunct6_backwards(arg_hashtag_: BitVector<6>) -> fvfmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101000))} => {fvfmafunct6::VF_VMADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b101001))} => {fvfmafunct6::VF_VNMADD}
        b__2 if {(b__2 == BitVector::<6>::new(0b101010))} => {fvfmafunct6::VF_VMSUB}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {fvfmafunct6::VF_VNMSUB}
        b__4 if {(b__4 == BitVector::<6>::new(0b101100))} => {fvfmafunct6::VF_VMACC}
        b__5 if {(b__5 == BitVector::<6>::new(0b101101))} => {fvfmafunct6::VF_VNMACC}
        b__6 if {(b__6 == BitVector::<6>::new(0b101110))} => {fvfmafunct6::VF_VMSAC}
        b__7 if {(b__7 == BitVector::<6>::new(0b101111))} => {fvfmafunct6::VF_VNMSAC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvfmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvfmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b101010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b101011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b101100))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b101101))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b101110))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvffunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvffunct6_backwards(arg_hashtag_: BitVector<6>) -> fwvffunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {fwvffunct6::FWVF_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110010))} => {fwvffunct6::FWVF_VSUB}
        b__2 if {(b__2 == BitVector::<6>::new(0b111000))} => {fwvffunct6::FWVF_VMUL}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvffunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvffunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110010))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111000))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvfmafunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvfmafunct6_backwards(arg_hashtag_: BitVector<6>) -> fwvfmafunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {fwvfmafunct6::FWVF_VMACC}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {fwvfmafunct6::FWVF_VNMACC}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {fwvfmafunct6::FWVF_VMSAC}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {fwvfmafunct6::FWVF_VNMSAC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwvfmafunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwvfmafunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b111100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b111101))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b111110))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b111111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwffunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fwffunct6_backwards(arg_hashtag_: BitVector<6>) -> fwffunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110100))} => {fwffunct6::FWF_VADD}
        b__1 if {(b__1 == BitVector::<6>::new(0b110110))} => {fwffunct6::FWF_VSUB}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fwffunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fwffunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110100))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110110))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vlewidth_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vlewidth_backwards(arg_hashtag_: BitVector<3>) -> vlewidth {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {vlewidth::VLE8}
        b__1 if {(b__1 == BitVector::<3>::new(0b101))} => {vlewidth::VLE16}
        b__2 if {(b__2 == BitVector::<3>::new(0b110))} => {vlewidth::VLE32}
        b__3 if {(b__3 == BitVector::<3>::new(0b111))} => {vlewidth::VLE64}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vlewidth_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vlewidth_backwards_matches(arg_hashtag_: BitVector<3>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<3>::new(0b000))} => {true}
        b__1 if {(b__1 == BitVector::<3>::new(0b101))} => {true}
        b__2 if {(b__2 == BitVector::<3>::new(0b110))} => {true}
        b__3 if {(b__3 == BitVector::<3>::new(0b111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_lsop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_lsop_backwards(arg_hashtag_: BitVector<7>) -> vmlsop {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<7>::new(0b0000111))} => {vmlsop::VLM}
        b__1 if {(b__1 == BitVector::<7>::new(0b0100111))} => {vmlsop::VSM}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_lsop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_lsop_backwards_matches(arg_hashtag_: BitVector<7>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<7>::new(0b0000111))} => {true}
        b__1 if {(b__1 == BitVector::<7>::new(0b0100111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mmfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_mmfunct6_backwards(arg_hashtag_: BitVector<6>) -> mmfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011001))} => {mmfunct6::MM_VMAND}
        b__1 if {(b__1 == BitVector::<6>::new(0b011101))} => {mmfunct6::MM_VMNAND}
        b__2 if {(b__2 == BitVector::<6>::new(0b011000))} => {mmfunct6::MM_VMANDN}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {mmfunct6::MM_VMXOR}
        b__4 if {(b__4 == BitVector::<6>::new(0b011010))} => {mmfunct6::MM_VMOR}
        b__5 if {(b__5 == BitVector::<6>::new(0b011110))} => {mmfunct6::MM_VMNOR}
        b__6 if {(b__6 == BitVector::<6>::new(0b011100))} => {mmfunct6::MM_VMORN}
        b__7 if {(b__7 == BitVector::<6>::new(0b011111))} => {mmfunct6::MM_VMXNOR}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_mmfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_mmfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011101))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011000))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b011010))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b011110))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b011100))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b011111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmfunct6_backwards(arg_hashtag_: BitVector<6>) -> vvmfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vvmfunct6::VVM_VMADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {vvmfunct6::VVM_VMSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmcfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmcfunct6_backwards(arg_hashtag_: BitVector<6>) -> vvmcfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vvmcfunct6::VVMC_VMADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {vvmcfunct6::VVMC_VMSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmcfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmcfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmsfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmsfunct6_backwards(arg_hashtag_: BitVector<6>) -> vvmsfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {vvmsfunct6::VVMS_VADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010010))} => {vvmsfunct6::VVMS_VSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvmsfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vvmsfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010010))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvcmpfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vvcmpfunct6_backwards(arg_hashtag_: BitVector<6>) -> vvcmpfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {vvcmpfunct6::VVCMP_VMSEQ}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {vvcmpfunct6::VVCMP_VMSNE}
        b__2 if {(b__2 == BitVector::<6>::new(0b011010))} => {vvcmpfunct6::VVCMP_VMSLTU}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {vvcmpfunct6::VVCMP_VMSLT}
        b__4 if {(b__4 == BitVector::<6>::new(0b011100))} => {vvcmpfunct6::VVCMP_VMSLEU}
        b__5 if {(b__5 == BitVector::<6>::new(0b011101))} => {vvcmpfunct6::VVCMP_VMSLE}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vvcmpfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vvcmpfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b011100))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b011101))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxmfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vxmfunct6::VXM_VMADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {vxmfunct6::VXM_VMSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmcfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmcfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxmcfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vxmcfunct6::VXMC_VMADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {vxmcfunct6::VXMC_VMSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmcfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmcfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010011))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmsfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmsfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxmsfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {vxmsfunct6::VXMS_VADC}
        b__1 if {(b__1 == BitVector::<6>::new(0b010010))} => {vxmsfunct6::VXMS_VSBC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxmsfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxmsfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b010010))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxcmpfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vxcmpfunct6_backwards(arg_hashtag_: BitVector<6>) -> vxcmpfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {vxcmpfunct6::VXCMP_VMSEQ}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {vxcmpfunct6::VXCMP_VMSNE}
        b__2 if {(b__2 == BitVector::<6>::new(0b011010))} => {vxcmpfunct6::VXCMP_VMSLTU}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {vxcmpfunct6::VXCMP_VMSLT}
        b__4 if {(b__4 == BitVector::<6>::new(0b011100))} => {vxcmpfunct6::VXCMP_VMSLEU}
        b__5 if {(b__5 == BitVector::<6>::new(0b011101))} => {vxcmpfunct6::VXCMP_VMSLE}
        b__6 if {(b__6 == BitVector::<6>::new(0b011110))} => {vxcmpfunct6::VXCMP_VMSGTU}
        b__7 if {(b__7 == BitVector::<6>::new(0b011111))} => {vxcmpfunct6::VXCMP_VMSGT}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vxcmpfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vxcmpfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b011100))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b011101))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b011110))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b011111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vimfunct6_backwards(arg_hashtag_: BitVector<6>) -> vimfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vimfunct6::VIM_VMADC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vimfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimcfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vimcfunct6_backwards(arg_hashtag_: BitVector<6>) -> vimcfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {vimcfunct6::VIMC_VMADC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimcfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vimcfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010001))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimsfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vimsfunct6_backwards(arg_hashtag_: BitVector<6>) -> vimsfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {vimsfunct6::VIMS_VADC}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vimsfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vimsfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b010000))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vicmpfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_vicmpfunct6_backwards(arg_hashtag_: BitVector<6>) -> vicmpfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {vicmpfunct6::VICMP_VMSEQ}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {vicmpfunct6::VICMP_VMSNE}
        b__2 if {(b__2 == BitVector::<6>::new(0b011100))} => {vicmpfunct6::VICMP_VMSLEU}
        b__3 if {(b__3 == BitVector::<6>::new(0b011101))} => {vicmpfunct6::VICMP_VMSLE}
        b__4 if {(b__4 == BitVector::<6>::new(0b011110))} => {vicmpfunct6::VICMP_VMSGTU}
        b__5 if {(b__5 == BitVector::<6>::new(0b011111))} => {vicmpfunct6::VICMP_VMSGT}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_vicmpfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_vicmpfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011100))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011101))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b011110))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b011111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvmfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvmfunct6_backwards(arg_hashtag_: BitVector<6>) -> fvvmfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {fvvmfunct6::FVVM_VMFEQ}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {fvvmfunct6::FVVM_VMFLE}
        b__2 if {(b__2 == BitVector::<6>::new(0b011011))} => {fvvmfunct6::FVVM_VMFLT}
        b__3 if {(b__3 == BitVector::<6>::new(0b011100))} => {fvvmfunct6::FVVM_VMFNE}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvvmfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvvmfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011011))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011100))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvfmfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_fvfmfunct6_backwards(arg_hashtag_: BitVector<6>) -> fvfmfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {fvfmfunct6::VFM_VMFEQ}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {fvfmfunct6::VFM_VMFLE}
        b__2 if {(b__2 == BitVector::<6>::new(0b011011))} => {fvfmfunct6::VFM_VMFLT}
        b__3 if {(b__3 == BitVector::<6>::new(0b011100))} => {fvfmfunct6::VFM_VMFNE}
        b__4 if {(b__4 == BitVector::<6>::new(0b011101))} => {fvfmfunct6::VFM_VMFGT}
        b__5 if {(b__5 == BitVector::<6>::new(0b011111))} => {fvfmfunct6::VFM_VMFGE}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_fvfmfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_fvfmfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b011000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b011001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b011011))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b011100))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b011101))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b011111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rivvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_rivvfunct6_backwards(arg_hashtag_: BitVector<6>) -> rivvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {rivvfunct6::IVV_VWREDSUMU}
        b__1 if {(b__1 == BitVector::<6>::new(0b110001))} => {rivvfunct6::IVV_VWREDSUM}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rivvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_rivvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b110000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b110001))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rmvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_rmvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> rmvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {rmvvfunct6::MVV_VREDSUM}
        b__1 if {(b__1 == BitVector::<6>::new(0b000001))} => {rmvvfunct6::MVV_VREDAND}
        b__2 if {(b__2 == BitVector::<6>::new(0b000010))} => {rmvvfunct6::MVV_VREDOR}
        b__3 if {(b__3 == BitVector::<6>::new(0b000011))} => {rmvvfunct6::MVV_VREDXOR}
        b__4 if {(b__4 == BitVector::<6>::new(0b000100))} => {rmvvfunct6::MVV_VREDMINU}
        b__5 if {(b__5 == BitVector::<6>::new(0b000101))} => {rmvvfunct6::MVV_VREDMIN}
        b__6 if {(b__6 == BitVector::<6>::new(0b000110))} => {rmvvfunct6::MVV_VREDMAXU}
        b__7 if {(b__7 == BitVector::<6>::new(0b000111))} => {rmvvfunct6::MVV_VREDMAX}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rmvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_rmvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000000))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000010))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000011))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b000100))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b000101))} => {true}
        b__6 if {(b__6 == BitVector::<6>::new(0b000110))} => {true}
        b__7 if {(b__7 == BitVector::<6>::new(0b000111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rfvvfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_rfvvfunct6_backwards(arg_hashtag_: BitVector<6>) -> rfvvfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000011))} => {rfvvfunct6::FVV_VFREDOSUM}
        b__1 if {(b__1 == BitVector::<6>::new(0b000001))} => {rfvvfunct6::FVV_VFREDUSUM}
        b__2 if {(b__2 == BitVector::<6>::new(0b000111))} => {rfvvfunct6::FVV_VFREDMAX}
        b__3 if {(b__3 == BitVector::<6>::new(0b000101))} => {rfvvfunct6::FVV_VFREDMIN}
        b__4 if {(b__4 == BitVector::<6>::new(0b110011))} => {rfvvfunct6::FVV_VFWREDOSUM}
        b__5 if {(b__5 == BitVector::<6>::new(0b110001))} => {rfvvfunct6::FVV_VFWREDUSUM}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_rfvvfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_rfvvfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b000011))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b000001))} => {true}
        b__2 if {(b__2 == BitVector::<6>::new(0b000111))} => {true}
        b__3 if {(b__3 == BitVector::<6>::new(0b000101))} => {true}
        b__4 if {(b__4 == BitVector::<6>::new(0b110011))} => {true}
        b__5 if {(b__5 == BitVector::<6>::new(0b110001))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// cbo_clean_flush_enabled
/// 
/// Generated from the Sail sources at `riscv_insts_zicbom.sail` L13.
pub fn cbo_clean_flush_enabled(core_ctx: &mut Core, p: Privilege) -> bool {
    let var_1 = bitvector_access({
        let var_4 = core_ctx.menvcfg;
        _get_MEnvcfg_CBCFE(var_4)
    }, 0);
    let var_2 = bitvector_access({
        let var_3 = core_ctx.senvcfg;
        _get_SEnvcfg_CBCFE(var_3)
    }, 0);
    feature_enabled_for_priv(core_ctx, p, var_1, var_2)
}

/// encdec_cbop_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_cbop_forwards(arg_hashtag_: cbop_zicbom) -> BitVector<12> {
    match arg_hashtag_ {
        cbop_zicbom::CBO_CLEAN => {BitVector::<12>::new(0b000000000001)}
        cbop_zicbom::CBO_FLUSH => {BitVector::<12>::new(0b000000000010)}
        cbop_zicbom::CBO_INVAL => {BitVector::<12>::new(0b000000000000)}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_cbop_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_cbop_backwards(arg_hashtag_: BitVector<12>) -> cbop_zicbom {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<12>::new(0b000000000001))} => {cbop_zicbom::CBO_CLEAN}
        b__1 if {(b__1 == BitVector::<12>::new(0b000000000010))} => {cbop_zicbom::CBO_FLUSH}
        b__2 if {(b__2 == BitVector::<12>::new(0b000000000000))} => {cbop_zicbom::CBO_INVAL}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_cbop_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_cbop_backwards_matches(arg_hashtag_: BitVector<12>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<12>::new(0b000000000001))} => {true}
        b__1 if {(b__1 == BitVector::<12>::new(0b000000000010))} => {true}
        b__2 if {(b__2 == BitVector::<12>::new(0b000000000000))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// cbie
/// 
/// Generated from the Sail sources at `riscv_insts_zicbom.sail` L38.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum cbie {
    CBIE_ILLEGAL,
    CBIE_EXEC_FLUSH,
    CBIE_EXEC_INVAL
}

/// encdec_cbie_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_cbie_backwards(arg_hashtag_: BitVector<2>) -> cbie {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<2>::new(0b00))} => {cbie::CBIE_ILLEGAL}
        b__1 if {(b__1 == BitVector::<2>::new(0b01))} => {cbie::CBIE_EXEC_FLUSH}
        b__2 if {(b__2 == BitVector::<2>::new(0b11))} => {cbie::CBIE_EXEC_INVAL}
        _ => {panic!("{}, l {}: {}", "riscv_insts_zicbom.sail", 44, "reserved CBIE")}
        _ => {panic!("Unreachable code")}
    }
}

/// checked_cbop
/// 
/// Generated from the Sail sources at `riscv_insts_zicbom.sail` L48.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum checked_cbop {
    CBOP_ILLEGAL,
    CBOP_ILLEGAL_VIRTUAL,
    CBOP_INVAL_FLUSH,
    CBOP_INVAL_INVAL
}

/// cbop_priv_check
/// 
/// Generated from the Sail sources at `riscv_insts_zicbom.sail` L51-64.
pub fn cbop_priv_check(core_ctx: &mut Core, p: Privilege) -> checked_cbop {
    let mCBIE: cbie = {
        let var_5 = {
            let var_6 = core_ctx.menvcfg;
            _get_MEnvcfg_CBIE(var_6)
        };
        encdec_cbie_backwards(var_5)
    };
    let sCBIE: cbie = if {currentlyEnabled(core_ctx, extension::Ext_S)} {
        {
            let var_3 = {
                let var_4 = core_ctx.senvcfg;
                _get_SEnvcfg_CBIE(var_4)
            };
            encdec_cbie_backwards(var_3)
        }
    } else {
        {
            let var_1 = {
                let var_2 = core_ctx.menvcfg;
                _get_MEnvcfg_CBIE(var_2)
            };
            encdec_cbie_backwards(var_1)
        }
    };
    match (p, mCBIE, sCBIE) {
        (Privilege::Machine, _, _) => {checked_cbop::CBOP_INVAL_INVAL}
        (_, cbie::CBIE_ILLEGAL, _) => {checked_cbop::CBOP_ILLEGAL}
        (Privilege::User, _, cbie::CBIE_ILLEGAL) => {checked_cbop::CBOP_ILLEGAL}
        (_, cbie::CBIE_EXEC_FLUSH, _) => {checked_cbop::CBOP_INVAL_FLUSH}
        (Privilege::User, _, cbie::CBIE_EXEC_FLUSH) => {checked_cbop::CBOP_INVAL_FLUSH}
        _ => {checked_cbop::CBOP_INVAL_INVAL}
        _ => {panic!("Unreachable code")}
    }
}

/// process_clean_inval
/// 
/// Generated from the Sail sources at `riscv_insts_zicbom.sail` L67-136.
pub fn process_clean_inval(core_ctx: &mut Core, rs1: regidx, cbop: cbop_zicbom) -> ExecutionResult {
    let rs1_val = rX_bits(core_ctx, rs1);
    let cache_block_size_exp = plat_cache_block_size_exp(core_ctx, ());
    let cache_block_size = i128::pow(2, (cache_block_size_exp as u32));
    let negative_offset = sub_vec((rs1_val & !(ones::<64>(cache_block_size_exp).zero_extend::<64>())), rs1_val);
    match ext_data_get_addr(core_ctx, rs1, negative_offset, AccessType::Read(Data), cache_block_size) {
        Ext_DataAddr_Check::Ext_DataAddr_Error(e) => {ExecutionResult::Ext_DataAddr_Check_Failure(e)}
        Ext_DataAddr_Check::Ext_DataAddr_OK(vaddr) => {{
            let res: Option<ExceptionType> = match panic!("Unsupported function: 'translateAddr'") {
                TR_Result::TR_Address((paddr, _)) => {{
                    let ep = {
                        let var_1 = core_ctx.mstatus;
                        let var_2 = core_ctx.cur_privilege;
                        effectivePrivilege(AccessType::Read(Data), var_1, var_2)
                    };
                    let exc_read = phys_access_check(core_ctx, AccessType::Read(Data), ep, paddr, cache_block_size);
                    let exc_write = phys_access_check(core_ctx, AccessType::Write(Data), ep, paddr, cache_block_size);
                    match (exc_read, exc_write) {
                        (Some(exc_read), Some(exc_write)) => {Some(exc_write)}
                        _ => {None}
                        _ => {panic!("Unreachable code")}
                    }
                }}
                TR_Result::TR_Failure((e, _)) => {Some(e)}
                _ => {panic!("Unreachable code")}
            };
            match res {
                None => {RETIRE_SUCCESS}
                Some(e) => {{
                    let e: ExceptionType = match e {
                        ExceptionType::E_Load_Access_Fault(()) => {ExceptionType::E_SAMO_Access_Fault(())}
                        ExceptionType::E_SAMO_Access_Fault(()) => {ExceptionType::E_SAMO_Access_Fault(())}
                        ExceptionType::E_Load_Page_Fault(()) => {ExceptionType::E_SAMO_Page_Fault(())}
                        ExceptionType::E_SAMO_Page_Fault(()) => {ExceptionType::E_SAMO_Page_Fault(())}
                        _ => {panic!("{}, l {}: {}", "riscv_insts_zicbom.sail", 125, "unexpected exception for cmo.clean/inval")}
                        _ => {panic!("Unreachable code")}
                    };
                    ExecutionResult::Memory_Exception((sub_virtaddr_xlenbits(vaddr, negative_offset), e))
                }}
                _ => {panic!("Unreachable code")}
            }
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_zvkfunct6_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_zvkfunct6_backwards(arg_hashtag_: BitVector<6>) -> zvkfunct6 {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {zvkfunct6::ZVK_VSHA2CH}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {zvkfunct6::ZVK_VSHA2CL}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_zvkfunct6_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn encdec_zvkfunct6_backwards_matches(arg_hashtag_: BitVector<6>) -> bool {
    match arg_hashtag_ {
        b__0 if {(b__0 == BitVector::<6>::new(0b101110))} => {true}
        b__1 if {(b__1 == BitVector::<6>::new(0b101111))} => {true}
        _ => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_forwards
/// 
/// Generated from the Sail sources.
pub fn encdec_forwards(core_ctx: &mut Core, arg_hashtag_: ast) -> BitVector<32> {
    match arg_hashtag_ {
        ast::UTYPE((imm, rd, op)) => {bitvector_concat::<20, 12, 32>((imm as BitVector<20>), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), encdec_uop_forwards(op)))}
        ast::JAL((v__2, rd)) if {(v__2.subrange::<0, 1, 1>() == BitVector::<1>::new(0b0))} => {let imm_19: BitVector<1> = v__2.subrange::<20, 21, 1>();
        let imm_8: BitVector<1> = v__2.subrange::<11, 12, 1>();
        let imm_7_0: BitVector<8> = v__2.subrange::<12, 20, 8>();
        let imm_19: BitVector<1> = v__2.subrange::<20, 21, 1>();
        let imm_18_13: BitVector<6> = v__2.subrange::<5, 11, 6>();
        let imm_12_9: BitVector<4> = v__2.subrange::<1, 5, 4>();
        bitvector_concat::<1, 31, 32>((imm_19 as BitVector<1>), bitvector_concat::<6, 25, 31>((imm_18_13 as BitVector<6>), bitvector_concat::<4, 21, 25>((imm_12_9 as BitVector<4>), bitvector_concat::<1, 20, 21>((imm_8 as BitVector<1>), bitvector_concat::<8, 12, 20>((imm_7_0 as BitVector<8>), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1101111)))))))}
        ast::JALR((imm, rs1, rd)) => {bitvector_concat::<12, 20, 32>((imm as BitVector<12>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1100111)))))}
        ast::BTYPE((v__4, rs2, rs1, op)) if {(v__4.subrange::<0, 1, 1>() == BitVector::<1>::new(0b0))} => {let imm7_6: BitVector<1> = v__4.subrange::<12, 13, 1>();
        let imm7_6: BitVector<1> = v__4.subrange::<12, 13, 1>();
        let imm7_5_0: BitVector<6> = v__4.subrange::<5, 11, 6>();
        let imm5_4_1: BitVector<4> = v__4.subrange::<1, 5, 4>();
        let imm5_0: BitVector<1> = v__4.subrange::<11, 12, 1>();
        bitvector_concat::<1, 31, 32>((imm7_6 as BitVector<1>), bitvector_concat::<6, 25, 31>((imm7_5_0 as BitVector<6>), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(encdec_bop_forwards(op), bitvector_concat::<4, 8, 12>((imm5_4_1 as BitVector<4>), bitvector_concat::<1, 7, 8>((imm5_0 as BitVector<1>), BitVector::<7>::new(0b1100011))))))))}
        ast::ITYPE((imm, rs1, rd, op)) => {bitvector_concat::<12, 20, 32>((imm as BitVector<12>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(encdec_iop_forwards(op), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011)))))}
        ast::SHIFTIOP((shamt, rs1, rd, sop::SLLI)) if {true} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b000000), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::SHIFTIOP((shamt, rs1, rd, sop::SRLI)) if {true} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b000000), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::SHIFTIOP((shamt, rs1, rd, sop::SRAI)) if {true} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b010000), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::ADD)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SLT)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b010), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SLTU)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b011), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::AND)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b111), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::OR)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b110), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::XOR)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SLL)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SRL)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SUB)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RTYPE((rs2, rs1, rd, rop::SRA)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::LOAD((imm, rs1, rd, is_unsigned, width, false, false)) if {valid_load_encdec(width, is_unsigned)} => {todo!("Unsupported: 'LOAD'")}
        ast::STORE((v__6, rs2, rs1, width, false, false)) if {(size_bytes_forwards(width) <= 8)} => {todo!("Unsupported: 'STORE'")}
        ast::ADDIW((imm, rs1, rd)) if {true} => {bitvector_concat::<12, 20, 32>((imm as BitVector<12>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0011011)))))}
        ast::RTYPEW((rs2, rs1, rd, ropw::ADDW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::RTYPEW((rs2, rs1, rd, ropw::SUBW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::RTYPEW((rs2, rs1, rd, ropw::SLLW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::RTYPEW((rs2, rs1, rd, ropw::SRLW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::RTYPEW((rs2, rs1, rd, ropw::SRAW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::SHIFTIWOP((shamt, rs1, rd, sopw::SLLIW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>((shamt as BitVector<5>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0011011))))))}
        ast::SHIFTIWOP((shamt, rs1, rd, sopw::SRLIW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000000), bitvector_concat::<5, 20, 25>((shamt as BitVector<5>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0011011))))))}
        ast::SHIFTIWOP((shamt, rs1, rd, sopw::SRAIW)) if {true} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100000), bitvector_concat::<5, 20, 25>((shamt as BitVector<5>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0011011))))))}
        ast::FENCE((pred, succ)) => {bitvector_concat::<4, 28, 32>(BitVector::<4>::new(0b0000), bitvector_concat::<4, 24, 28>((pred as BitVector<4>), bitvector_concat::<4, 20, 24>((succ as BitVector<4>), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b0001111)))))))}
        ast::FENCE_TSO((pred, succ)) => {bitvector_concat::<4, 28, 32>(BitVector::<4>::new(0b1000), bitvector_concat::<4, 24, 28>((pred as BitVector<4>), bitvector_concat::<4, 20, 24>((succ as BitVector<4>), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b0001111)))))))}
        ast::ECALL(()) => {bitvector_concat::<12, 20, 32>(BitVector::<12>::new(0b000000000000), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011)))))}
        ast::MRET(()) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0011000), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b00010), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::SRET(()) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0001000), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b00010), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::EBREAK(()) => {bitvector_concat::<12, 20, 32>(BitVector::<12>::new(0b000000000001), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011)))))}
        ast::WFI(()) => {bitvector_concat::<12, 20, 32>(BitVector::<12>::new(0b000100000101), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011)))))}
        ast::SFENCE_VMA((rs1, rs2)) => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0001001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::FENCEI(()) if {currentlyEnabled(core_ctx, extension::Ext_Zifencei)} => {bitvector_concat::<12, 20, 32>(BitVector::<12>::new(0b000000000000), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b0001111)))))}
        ast::LOADRES((aq, rl, rs1, size, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zalrsc) && lrsc_width_valid(size))} => {todo!("Unsupported: 'LOADRES'")}
        ast::STORECON((aq, rl, rs2, rs1, size, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zalrsc) && lrsc_width_valid(size))} => {todo!("Unsupported: 'STORECON'")}
        ast::AMO((op, aq, rl, rs2, rs1, size, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zaamo) && amo_width_valid(core_ctx, size))} => {todo!("Unsupported: 'AMO'")}
        ast::MUL((rs2, rs1, rd, mul_op)) if {(currentlyEnabled(core_ctx, extension::Ext_M) || currentlyEnabled(core_ctx, extension::Ext_Zmmul))} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(encdec_mul_op_forwards(mul_op), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::DIV((rs2, rs1, rd, s)) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<2, 13, 15>(BitVector::<2>::new(0b10), bitvector_concat::<1, 12, 13>(bool_not_bits_forwards(s), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011)))))))}
        ast::REM((rs2, rs1, rd, s)) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<2, 13, 15>(BitVector::<2>::new(0b11), bitvector_concat::<1, 12, 13>(bool_not_bits_forwards(s), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011)))))))}
        ast::MULW((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_M) || currentlyEnabled(core_ctx, extension::Ext_Zmmul))} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::DIVW((rs2, rs1, rd, s)) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<2, 13, 15>(BitVector::<2>::new(0b10), bitvector_concat::<1, 12, 13>(bool_not_bits_forwards(s), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011)))))))}
        ast::REMW((rs2, rs1, rd, s)) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000001), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<2, 13, 15>(BitVector::<2>::new(0b11), bitvector_concat::<1, 12, 13>(bool_not_bits_forwards(s), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011)))))))}
        ast::CSRReg((csr, rs1, rd, op)) => {bitvector_concat::<12, 20, 32>((csr as BitVector<12>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<1, 14, 15>(BitVector::<1>::new(0b0), bitvector_concat::<2, 12, 14>(encdec_csrop_forwards(op), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1110011))))))}
        ast::CSRImm((csr, imm, rd, op)) => {bitvector_concat::<12, 20, 32>((csr as BitVector<12>), bitvector_concat::<5, 15, 20>((imm as BitVector<5>), bitvector_concat::<1, 14, 15>(BitVector::<1>::new(0b1), bitvector_concat::<2, 12, 14>(encdec_csrop_forwards(op), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1110011))))))}
        ast::FENCE_RESERVED((fm, pred, succ, rs, rd)) if {(((fm != BitVector::<4>::new(0b0000)) && (fm != BitVector::<4>::new(0b1000))) || ((rs != zreg) || (rd != zreg)))} => {bitvector_concat::<4, 28, 32>((fm as BitVector<4>), bitvector_concat::<4, 24, 28>((pred as BitVector<4>), bitvector_concat::<4, 20, 24>((succ as BitVector<4>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0001111)))))))}
        ast::FENCEI_RESERVED((imm, rs, rd)) if {((imm != BitVector::<12>::new(0b000000000000)) || ((rs != zreg) || (rd != zreg)))} => {bitvector_concat::<12, 20, 32>((imm as BitVector<12>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0001111)))))}
        ast::LOAD_FP((imm, rs1, rd, word_width::HALF)) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {todo!("Unsupported: 'LOAD_FP'")}
        ast::LOAD_FP((imm, rs1, rd, word_width::WORD)) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {todo!("Unsupported: 'LOAD_FP'")}
        ast::LOAD_FP((imm, rs1, rd, word_width::DOUBLE)) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {todo!("Unsupported: 'LOAD_FP'")}
        ast::STORE_FP((v__7, rs2, rs1, word_width::HALF)) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {todo!("Unsupported: 'STORE_FP'")}
        ast::STORE_FP((v__8, rs2, rs1, word_width::WORD)) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {todo!("Unsupported: 'STORE_FP'")}
        ast::STORE_FP((v__9, rs2, rs1, word_width::DOUBLE)) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {todo!("Unsupported: 'STORE_FP'")}
        ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FMADD_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_S'")}
        ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FMSUB_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_S'")}
        ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FNMSUB_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_S'")}
        ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FNMADD_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_S'")}
        ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FADD_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_S'")}
        ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FSUB_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_S'")}
        ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FMUL_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_S'")}
        ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FDIV_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_S'")}
        ast::F_UN_RM_FF_TYPE_S((rs1, rm, rd, f_un_rm_ff_op_S::FSQRT_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_W_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_WU_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_W)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_WU)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_L_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_LU_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_L)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_LU)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJ_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJN_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJX_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMIN_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMAX_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FEQ_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLT_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLE_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FCLASS_S)) if {haveSingleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_TYPE_X_S'")}
        ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FMV_X_W)) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {todo!("Unsupported: 'F_UN_TYPE_X_S'")}
        ast::F_UN_TYPE_F_S((rs1, rd, f_un_op_f_S::FMV_W_X)) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {todo!("Unsupported: 'F_UN_TYPE_F_S'")}
        ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FMADD_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_D'")}
        ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FMSUB_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_D'")}
        ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FNMSUB_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_D'")}
        ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FNMADD_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_D'")}
        ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FADD_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_D'")}
        ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FSUB_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_D'")}
        ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FMUL_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_D'")}
        ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FDIV_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FSQRT_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_W_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_WU_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_W)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_WU)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_S_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_D_S)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_L_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_LU_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_L)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_LU)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJ_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJN_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJX_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMIN_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMAX_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FEQ_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLT_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLE_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FCLASS_D)) if {haveDoubleFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_X_TYPE_D'")}
        ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FMV_X_D)) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {todo!("Unsupported: 'F_UN_X_TYPE_D'")}
        ast::F_UN_F_TYPE_D((rs1, rd, f_un_f_op_D::FMV_D_X)) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {todo!("Unsupported: 'F_UN_F_TYPE_D'")}
        ast::SINVAL_VMA((rs1, rs2)) if {currentlyEnabled(core_ctx, extension::Ext_Svinval)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0001011), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::SFENCE_W_INVAL(()) if {currentlyEnabled(core_ctx, extension::Ext_Svinval)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0001100), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b00000), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::SFENCE_INVAL_IR(()) if {currentlyEnabled(core_ctx, extension::Ext_Svinval)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0001100), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b00001), bitvector_concat::<5, 15, 20>(BitVector::<5>::new(0b00000), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b1110011))))))}
        ast::SLLIUW((shamt, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b000010), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0011011))))))}
        ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::ADDUW)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH1ADDUW)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b010), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH2ADDUW)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH3ADDUW)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b110), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH1ADD)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b010), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH2ADD)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH3ADD)) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b110), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::RORIW((shamt, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'RORIW'")}
        ast::RORI((shamt, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'RORI'")}
        ast::ZBB_RTYPEW((rs2, rs1, rd, bropw_zbb::ROLW)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPEW'")}
        ast::ZBB_RTYPEW((rs2, rs1, rd, bropw_zbb::RORW)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPEW'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ANDN)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ORN)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::XNOR)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MAX)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MAXU)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MIN)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MINU)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ROL)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ROR)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_EXTOP((rs1, rd, extop_zbb::SEXTB)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_EXTOP'")}
        ast::ZBB_EXTOP((rs1, rd, extop_zbb::SEXTH)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_EXTOP'")}
        ast::ZBB_EXTOP((rs1, rd, extop_zbb::ZEXTH)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ZBB_EXTOP'")}
        ast::REV8((rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {todo!("Unsupported: 'REV8'")}
        ast::ORCB((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'ORCB'")}
        ast::CPOP((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CPOP'")}
        ast::CPOPW((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CPOPW'")}
        ast::CLZ((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CLZ'")}
        ast::CLZW((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CLZW'")}
        ast::CTZ((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CTZ'")}
        ast::CTZW((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {todo!("Unsupported: 'CTZW'")}
        ast::CLMUL((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbc) || currentlyEnabled(core_ctx, extension::Ext_Zbkc))} => {todo!("Unsupported: 'CLMUL'")}
        ast::CLMULH((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zbc) || currentlyEnabled(core_ctx, extension::Ext_Zbkc))} => {todo!("Unsupported: 'CLMULH'")}
        ast::CLMULR((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbc)} => {todo!("Unsupported: 'CLMULR'")}
        ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BCLRI)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b010010), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BEXTI)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b010010), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BINVI)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b011010), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BSETI)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<6, 26, 32>(BitVector::<6>::new(0b001010), bitvector_concat::<6, 20, 26>((shamt as BitVector<6>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011))))))}
        ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BCLR)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BEXT)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0100100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BINV)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0110100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BSET)) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FADD_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_H'")}
        ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FSUB_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_H'")}
        ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FMUL_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_H'")}
        ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FDIV_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_RM_TYPE_H'")}
        ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FMADD_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_H'")}
        ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FMSUB_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_H'")}
        ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FNMSUB_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_H'")}
        ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FNMADD_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_MADD_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJ_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJN_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJX_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMIN_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMAX_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FEQ_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLT_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLE_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FSQRT_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_W_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_WU_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_W)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_WU)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_S)) if {haveHalfMin(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_D)) if {(haveHalfMin(core_ctx, ()) && haveDoubleFPU(core_ctx, ()))} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_S_H)) if {haveHalfMin(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_D_H)) if {(haveHalfMin(core_ctx, ()) && haveDoubleFPU(core_ctx, ()))} => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_L_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_LU_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_L)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_LU)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FCLASS_H)) if {haveHalfFPU(core_ctx, ())} => {todo!("Unsupported: 'F_UN_X_TYPE_H'")}
        ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FMV_X_H)) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {todo!("Unsupported: 'F_UN_X_TYPE_H'")}
        ast::F_UN_F_TYPE_H((rs1, rd, f_un_f_op_H::FMV_H_X)) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {todo!("Unsupported: 'F_UN_F_TYPE_H'")}
        ast::FLI_H((constantidx, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLI_H'")}
        ast::FLI_S((constantidx, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FLI_S'")}
        ast::FLI_D((constantidx, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLI_D'")}
        ast::FMINM_H((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FMINM_H'")}
        ast::FMAXM_H((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FMAXM_H'")}
        ast::FMINM_S((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FMINM_S'")}
        ast::FMAXM_S((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FMAXM_S'")}
        ast::FMINM_D((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FMINM_D'")}
        ast::FMAXM_D((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FMAXM_D'")}
        ast::FROUND_H((rs1, rm, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FROUND_H'")}
        ast::FROUNDNX_H((rs1, rm, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FROUNDNX_H'")}
        ast::FROUND_S((rs1, rm, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FROUND_S'")}
        ast::FROUNDNX_S((rs1, rm, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FROUNDNX_S'")}
        ast::FROUND_D((rs1, rm, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FROUND_D'")}
        ast::FROUNDNX_D((rs1, rm, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FROUNDNX_D'")}
        ast::FMVH_X_D((rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && (currentlyEnabled(core_ctx, extension::Ext_Zfa) && in32BitMode(core_ctx, ())))} => {todo!("Unsupported: 'FMVH_X_D'")}
        ast::FMVP_D_X((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && (currentlyEnabled(core_ctx, extension::Ext_Zfa) && in32BitMode(core_ctx, ())))} => {todo!("Unsupported: 'FMVP_D_X'")}
        ast::FLEQ_H((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLEQ_H'")}
        ast::FLTQ_H((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLTQ_H'")}
        ast::FLEQ_S((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FLEQ_S'")}
        ast::FLTQ_S((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {todo!("Unsupported: 'FLTQ_S'")}
        ast::FLEQ_D((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLEQ_D'")}
        ast::FLTQ_D((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FLTQ_D'")}
        ast::FCVTMOD_W_D((rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {todo!("Unsupported: 'FCVTMOD_W_D'")}
        ast::SHA256SUM0((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA256SUM0'")}
        ast::SHA256SUM1((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA256SUM1'")}
        ast::SHA256SIG0((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA256SIG0'")}
        ast::SHA256SIG1((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA256SIG1'")}
        ast::AES64KS1I((rnum, rs1, rd)) if {((currentlyEnabled(core_ctx, extension::Ext_Zkne) || currentlyEnabled(core_ctx, extension::Ext_Zknd)) && _operator_smaller_u_(rnum, BitVector::<4>::new(0b1011)))} => {todo!("Unsupported: 'AES64KS1I'")}
        ast::AES64IM((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {todo!("Unsupported: 'AES64IM'")}
        ast::AES64KS2((rs2, rs1, rd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zkne) || currentlyEnabled(core_ctx, extension::Ext_Zknd))} => {todo!("Unsupported: 'AES64KS2'")}
        ast::AES64ESM((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zkne)} => {todo!("Unsupported: 'AES64ESM'")}
        ast::AES64ES((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zkne)} => {todo!("Unsupported: 'AES64ES'")}
        ast::AES64DSM((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {todo!("Unsupported: 'AES64DSM'")}
        ast::AES64DS((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {todo!("Unsupported: 'AES64DS'")}
        ast::SHA512SUM0((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA512SUM0'")}
        ast::SHA512SUM1((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA512SUM1'")}
        ast::SHA512SIG0((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA512SIG0'")}
        ast::SHA512SIG1((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {todo!("Unsupported: 'SHA512SIG1'")}
        ast::SM3P0((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zksh)} => {bitvector_concat::<2, 30, 32>(BitVector::<2>::new(0b00), bitvector_concat::<5, 25, 30>(BitVector::<5>::new(0b01000), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b01000), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011)))))))}
        ast::SM3P1((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zksh)} => {bitvector_concat::<2, 30, 32>(BitVector::<2>::new(0b00), bitvector_concat::<5, 25, 30>(BitVector::<5>::new(0b01000), bitvector_concat::<5, 20, 25>(BitVector::<5>::new(0b01001), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b001), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011)))))))}
        ast::SM4ED((bs, rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zksed)} => {bitvector_concat::<2, 30, 32>((bs as BitVector<2>), bitvector_concat::<5, 25, 30>(BitVector::<5>::new(0b11000), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011)))))))}
        ast::SM4KS((bs, rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zksed)} => {bitvector_concat::<2, 30, 32>((bs as BitVector<2>), bitvector_concat::<5, 25, 30>(BitVector::<5>::new(0b11010), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b000), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011)))))))}
        ast::ZBKB_RTYPE((rs2, rs1, rd, brop_zbkb::PACK)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBKB_RTYPE((rs2, rs1, rd, brop_zbkb::PACKH)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b111), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZBKB_PACKW((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0111011))))))}
        ast::BREV8((rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {bitvector_concat::<12, 20, 32>(BitVector::<12>::new(0b011010000111), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0010011)))))}
        ast::XPERM8((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkx)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::XPERM4((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zbkx)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0010100), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b010), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_EQZ)) if {currentlyEnabled(core_ctx, extension::Ext_Zicond)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000111), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b101), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_NEZ)) if {currentlyEnabled(core_ctx, extension::Ext_Zicond)} => {bitvector_concat::<7, 25, 32>(BitVector::<7>::new(0b0000111), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b111), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b0110011))))))}
        ast::VSETVLI((ma, ta, sew, lmul, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSETVLI'")}
        ast::VSETVL((rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSETVL'")}
        ast::VSETIVLI((ma, ta, sew, lmul, uimm, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSETIVLI'")}
        ast::VVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VVTYPE'")}
        ast::NVSTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NVSTYPE'")}
        ast::NVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NVTYPE'")}
        ast::MASKTYPEV((vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MASKTYPEV'")}
        ast::MOVETYPEV((vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MOVETYPEV'")}
        ast::VXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXTYPE'")}
        ast::NXSTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NXSTYPE'")}
        ast::NXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NXTYPE'")}
        ast::VXSG((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXSG'")}
        ast::MASKTYPEX((vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MASKTYPEX'")}
        ast::MOVETYPEX((rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MOVETYPEX'")}
        ast::VITYPE((funct6, vm, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VITYPE'")}
        ast::NISTYPE((funct6, vm, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NISTYPE'")}
        ast::NITYPE((funct6, vm, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'NITYPE'")}
        ast::VISG((funct6, vm, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VISG'")}
        ast::MASKTYPEI((vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MASKTYPEI'")}
        ast::MOVETYPEI((vd, simm)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MOVETYPEI'")}
        ast::VMVRTYPE((vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMVRTYPE'")}
        ast::MVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MVVTYPE'")}
        ast::MVVMATYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MVVMATYPE'")}
        ast::WVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WVVTYPE'")}
        ast::WVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WVTYPE'")}
        ast::WMVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WMVVTYPE'")}
        ast::VEXT2TYPE((funct6, vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VEXT2TYPE'")}
        ast::VEXT4TYPE((funct6, vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VEXT4TYPE'")}
        ast::VEXT8TYPE((funct6, vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VEXT8TYPE'")}
        ast::VMVXS((vs2, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMVXS'")}
        ast::MVVCOMPRESS((vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MVVCOMPRESS'")}
        ast::MVXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MVXTYPE'")}
        ast::MVXMATYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MVXMATYPE'")}
        ast::WVXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WVXTYPE'")}
        ast::WXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WXTYPE'")}
        ast::WMVXTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'WMVXTYPE'")}
        ast::VMVSX((rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMVSX'")}
        ast::FVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVVTYPE'")}
        ast::FVVMATYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVVMATYPE'")}
        ast::FWVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWVVTYPE'")}
        ast::FWVVMATYPE((funct6, vm, vs1, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWVVMATYPE'")}
        ast::FWVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWVTYPE'")}
        ast::VFUNARY0((vm, vs2, vfunary0, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFUNARY0'")}
        ast::VFWUNARY0((vm, vs2, vfwunary0, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFWUNARY0'")}
        ast::VFNUNARY0((vm, vs2, vfnunary0, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFNUNARY0'")}
        ast::VFUNARY1((vm, vs2, vfunary1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFUNARY1'")}
        ast::VFMVFS((vs2, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFMVFS'")}
        ast::FVFTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVFTYPE'")}
        ast::FVFMATYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVFMATYPE'")}
        ast::FWVFTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWVFTYPE'")}
        ast::FWVFMATYPE((funct6, vm, rs1, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWVFMATYPE'")}
        ast::FWFTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FWFTYPE'")}
        ast::VFMERGE((vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFMERGE'")}
        ast::VFMV((rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFMV'")}
        ast::VFMVSF((rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFMVSF'")}
        ast::VLSEGTYPE((nf, vm, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLSEGTYPE'")}
        ast::VLSEGFFTYPE((nf, vm, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLSEGFFTYPE'")}
        ast::VSSEGTYPE((nf, vm, rs1, width, vs3)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSSEGTYPE'")}
        ast::VLSSEGTYPE((nf, vm, rs2, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLSSEGTYPE'")}
        ast::VSSSEGTYPE((nf, vm, rs2, rs1, width, vs3)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSSSEGTYPE'")}
        ast::VLUXSEGTYPE((nf, vm, vs2, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLUXSEGTYPE'")}
        ast::VLOXSEGTYPE((nf, vm, vs2, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLOXSEGTYPE'")}
        ast::VSUXSEGTYPE((nf, vm, vs2, rs1, width, vs3)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSUXSEGTYPE'")}
        ast::VSOXSEGTYPE((nf, vm, vs2, rs1, width, vs3)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSOXSEGTYPE'")}
        ast::VLRETYPE((nf, rs1, width, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VLRETYPE'")}
        ast::VSRETYPE((nf, rs1, vs3)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VSRETYPE'")}
        ast::VMTYPE((rs1, vd_or_vs3, op)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMTYPE'")}
        ast::MMTYPE((funct6, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'MMTYPE'")}
        ast::VCPOP_M((vm, vs2, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VCPOP_M'")}
        ast::VFIRST_M((vm, vs2, rd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VFIRST_M'")}
        ast::VMSBF_M((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMSBF_M'")}
        ast::VMSIF_M((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMSIF_M'")}
        ast::VMSOF_M((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VMSOF_M'")}
        ast::VIOTA_M((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VIOTA_M'")}
        ast::VID_V((vm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VID_V'")}
        ast::VVMTYPE((funct6, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VVMTYPE'")}
        ast::VVMCTYPE((funct6, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VVMCTYPE'")}
        ast::VVMSTYPE((funct6, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VVMSTYPE'")}
        ast::VVCMPTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VVCMPTYPE'")}
        ast::VXMTYPE((funct6, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXMTYPE'")}
        ast::VXMCTYPE((funct6, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXMCTYPE'")}
        ast::VXMSTYPE((funct6, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXMSTYPE'")}
        ast::VXCMPTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VXCMPTYPE'")}
        ast::VIMTYPE((funct6, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VIMTYPE'")}
        ast::VIMCTYPE((funct6, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VIMCTYPE'")}
        ast::VIMSTYPE((funct6, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VIMSTYPE'")}
        ast::VICMPTYPE((funct6, vm, vs2, simm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'VICMPTYPE'")}
        ast::FVVMTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVVMTYPE'")}
        ast::FVFMTYPE((funct6, vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'FVFMTYPE'")}
        ast::RIVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'RIVVTYPE'")}
        ast::RMVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'RMVVTYPE'")}
        ast::RFVVTYPE((funct6, vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {todo!("Unsupported: 'RFVVTYPE'")}
        ast::ZICBOM((cbop, rs1)) if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} => {bitvector_concat::<12, 20, 32>(encdec_cbop_forwards(cbop), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b010), bitvector_concat::<5, 7, 12>(BitVector::<5>::new(0b00000), BitVector::<7>::new(0b0001111)))))}
        ast::ZICBOZ(rs1) if {currentlyEnabled(core_ctx, extension::Ext_Zicboz)} => {todo!("Unsupported: 'ZICBOZ'")}
        ast::VANDN_VV((vm, vs1, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VANDN_VV'")}
        ast::VANDN_VX((vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VANDN_VX'")}
        ast::VBREV_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VBREV_V'")}
        ast::VBREV8_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VBREV8_V'")}
        ast::VREV8_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VREV8_V'")}
        ast::VCLZ_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VCLZ_V'")}
        ast::VCTZ_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VCTZ_V'")}
        ast::VCPOP_V((vm, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VCPOP_V'")}
        ast::VROL_VV((vm, vs1, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VROL_VV'")}
        ast::VROL_VX((vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VROL_VX'")}
        ast::VROR_VV((vm, vs1, vs2, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VROR_VV'")}
        ast::VROR_VX((vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VROR_VX'")}
        ast::VROR_VI((vm, vs2, uimm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {todo!("Unsupported: 'VROR_VI'")}
        ast::VWSLL_VV((vm, vs2, vs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VWSLL_VV'")}
        ast::VWSLL_VX((vm, vs2, rs1, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VWSLL_VX'")}
        ast::VWSLL_VI((vm, vs2, uimm, vd)) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {todo!("Unsupported: 'VWSLL_VI'")}
        ast::VCLMUL_VV((vm, vs2, vs1, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {todo!("Unsupported: 'VCLMUL_VV'")}
        ast::VCLMUL_VX((vm, vs2, rs1, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {todo!("Unsupported: 'VCLMUL_VX'")}
        ast::VCLMULH_VV((vm, vs2, vs1, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {todo!("Unsupported: 'VCLMULH_VV'")}
        ast::VCLMULH_VX((vm, vs2, rs1, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {todo!("Unsupported: 'VCLMULH_VX'")}
        ast::VSHA2MS_VV((vs2, vs1, vd)) if {((currentlyEnabled(core_ctx, extension::Ext_Zvknha) && ((get_sew(core_ctx, ()) == 32) as bool)) || ((currentlyEnabled(core_ctx, extension::Ext_Zvknhb) && (((get_sew(core_ctx, ()) == 32) || ((get_sew(core_ctx, ()) == 64) as bool)) as bool)) && zvknhab_check_encdec(core_ctx, vs2, vs1, vd)))} => {todo!("Unsupported: 'VSHA2MS_VV'")}
        ast::ZVKSHA2TYPE((funct6, vs2, vs1, vd)) if {((currentlyEnabled(core_ctx, extension::Ext_Zvknha) && ((get_sew(core_ctx, ()) == 32) as bool)) || ((currentlyEnabled(core_ctx, extension::Ext_Zvknhb) && (((get_sew(core_ctx, ()) == 32) || ((get_sew(core_ctx, ()) == 64) as bool)) as bool)) && zvknhab_check_encdec(core_ctx, vs2, vs1, vd)))} => {todo!("Unsupported: 'ZVKSHA2TYPE'")}
        ast::VSM3ME_VV((vs2, vs1, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvksh) && (((get_sew(core_ctx, ()) == 32) && (zvk_check_encdec(core_ctx, 256, 8) && {
                let var_1 = get_lmul_pow(core_ctx, ());
                zvk_valid_reg_overlap(vs2, vd, var_1)
            })) as bool))} => {todo!("Unsupported: 'VSM3ME_VV'")}
        ast::VSM3C_VI((vs2, uimm, vd)) if {(currentlyEnabled(core_ctx, extension::Ext_Zvksh) && (((get_sew(core_ctx, ()) == 32) && (zvk_check_encdec(core_ctx, 256, 8) && {
                let var_2 = get_lmul_pow(core_ctx, ());
                zvk_valid_reg_overlap(vs2, vd, var_2)
            })) as bool))} => {todo!("Unsupported: 'VSM3C_VI'")}
        ast::ZIMOP_MOP_R((v__10, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zimop)} => {let mop_30: BitVector<1> = v__10.subrange::<4, 5, 1>();
        let mop_30: BitVector<1> = v__10.subrange::<4, 5, 1>();
        let mop_27_26: BitVector<2> = v__10.subrange::<2, 4, 2>();
        let mop_21_20: BitVector<2> = v__10.subrange::<0, 2, 2>();
        bitvector_concat::<1, 31, 32>(BitVector::<1>::new(0b1), bitvector_concat::<1, 30, 31>((mop_30 as BitVector<1>), bitvector_concat::<2, 28, 30>(BitVector::<2>::new(0b00), bitvector_concat::<2, 26, 28>((mop_27_26 as BitVector<2>), bitvector_concat::<4, 22, 26>(BitVector::<4>::new(0b0111), bitvector_concat::<2, 20, 22>((mop_21_20 as BitVector<2>), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1110011))))))))))}
        ast::ZIMOP_MOP_RR((v__11, rs2, rs1, rd)) if {currentlyEnabled(core_ctx, extension::Ext_Zimop)} => {let mop_30: BitVector<1> = v__11.subrange::<2, 3, 1>();
        let mop_30: BitVector<1> = v__11.subrange::<2, 3, 1>();
        let mop_27_26: BitVector<2> = v__11.subrange::<0, 2, 2>();
        bitvector_concat::<1, 31, 32>(BitVector::<1>::new(0b1), bitvector_concat::<1, 30, 31>((mop_30 as BitVector<1>), bitvector_concat::<2, 28, 30>(BitVector::<2>::new(0b00), bitvector_concat::<2, 26, 28>((mop_27_26 as BitVector<2>), bitvector_concat::<1, 25, 26>(BitVector::<1>::new(0b1), bitvector_concat::<5, 20, 25>(encdec_reg_forwards(rs2), bitvector_concat::<5, 15, 20>(encdec_reg_forwards(rs1), bitvector_concat::<3, 12, 15>(BitVector::<3>::new(0b100), bitvector_concat::<5, 7, 12>(encdec_reg_forwards(rd), BitVector::<7>::new(0b1110011))))))))))}
        ast::ILLEGAL(s) => {s}
        _ => {panic!("Unreachable code")}
    }
}

/// encdec_backwards
/// 
/// Generated from the Sail sources.
pub fn encdec_backwards(core_ctx: &mut Core, arg_hashtag_: BitVector<32>) -> ast {
    let head_exp_hashtag_ = arg_hashtag_;
    match match head_exp_hashtag_ {
        v__1566 if {let mapping1_hashtag__var_1158: BitVector<7> = v__1566.subrange::<0, 7, 7>();
        let mapping0_hashtag__var_1159: BitVector<5> = v__1566.subrange::<7, 12, 5>();
        (encdec_reg_backwards_matches(mapping0_hashtag__var_1159) && encdec_uop_backwards_matches(mapping1_hashtag__var_1158))} => {let imm: BitVector<20> = v__1566.subrange::<12, 32, 20>();
        let mapping1_hashtag_: BitVector<7> = v__1566.subrange::<0, 7, 7>();
        let mapping0_hashtag_: BitVector<5> = v__1566.subrange::<7, 12, 5>();
        let imm: BitVector<20> = v__1566.subrange::<12, 32, 20>();
        match (encdec_reg_backwards(mapping0_hashtag_), encdec_uop_backwards(mapping1_hashtag_)) {
            (rd, op) => {Some(ast::UTYPE((imm, rd, op)))}
            _ => {None}
            _ => {panic!("Unreachable code")}
        }}
        _ => {None}
        _ => {panic!("Unreachable code")}
    } {
        Some(result) => {result}
        None => {match match head_exp_hashtag_ {
            v__1564 if {let mapping2_hashtag__var_1157: BitVector<5> = v__1564.subrange::<7, 12, 5>();
            (encdec_reg_backwards_matches(mapping2_hashtag__var_1157) && (v__1564.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1101111)))} => {let imm_19: BitVector<1> = v__1564.subrange::<31, 32, 1>();
            let mapping2_hashtag_: BitVector<5> = v__1564.subrange::<7, 12, 5>();
            let imm_8: BitVector<1> = v__1564.subrange::<20, 21, 1>();
            let imm_7_0: BitVector<8> = v__1564.subrange::<12, 20, 8>();
            let imm_19: BitVector<1> = v__1564.subrange::<31, 32, 1>();
            let imm_18_13: BitVector<6> = v__1564.subrange::<25, 31, 6>();
            let imm_12_9: BitVector<4> = v__1564.subrange::<21, 25, 4>();
            match encdec_reg_backwards(mapping2_hashtag_) {
                rd => {Some(ast::JAL((bitvector_concat::<1, 20, 21>((imm_19 as BitVector<1>), bitvector_concat::<8, 12, 20>((imm_7_0 as BitVector<8>), bitvector_concat::<1, 11, 12>((imm_8 as BitVector<1>), bitvector_concat::<6, 5, 11>((imm_18_13 as BitVector<6>), bitvector_concat::<4, 1, 5>((imm_12_9 as BitVector<4>), BitVector::<1>::new(0b0)))))), rd)))}
                _ => {None}
                _ => {panic!("Unreachable code")}
            }}
            _ => {None}
            _ => {panic!("Unreachable code")}
        } {
            Some(result) => {result}
            None => {match match head_exp_hashtag_ {
                v__1561 if {let mapping4_hashtag__var_1155: BitVector<5> = v__1561.subrange::<7, 12, 5>();
                let mapping3_hashtag__var_1156: BitVector<5> = v__1561.subrange::<15, 20, 5>();
                ((encdec_reg_backwards_matches(mapping3_hashtag__var_1156) && encdec_reg_backwards_matches(mapping4_hashtag__var_1155)) && ((v__1561.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1561.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1100111))))} => {let imm: BitVector<12> = v__1561.subrange::<20, 32, 12>();
                let mapping4_hashtag_: BitVector<5> = v__1561.subrange::<7, 12, 5>();
                let mapping3_hashtag_: BitVector<5> = v__1561.subrange::<15, 20, 5>();
                let imm: BitVector<12> = v__1561.subrange::<20, 32, 12>();
                match (encdec_reg_backwards(mapping3_hashtag_), encdec_reg_backwards(mapping4_hashtag_)) {
                    (rs1, rd) => {Some(ast::JALR((imm, rs1, rd)))}
                    _ => {None}
                    _ => {panic!("Unreachable code")}
                }}
                _ => {None}
                _ => {panic!("Unreachable code")}
            } {
                Some(result) => {result}
                None => {match match head_exp_hashtag_ {
                    v__1559 if {let mapping7_hashtag__var_1152: BitVector<3> = v__1559.subrange::<12, 15, 3>();
                    let mapping6_hashtag__var_1153: BitVector<5> = v__1559.subrange::<15, 20, 5>();
                    let mapping5_hashtag__var_1154: BitVector<5> = v__1559.subrange::<20, 25, 5>();
                    ((encdec_reg_backwards_matches(mapping5_hashtag__var_1154) && (encdec_reg_backwards_matches(mapping6_hashtag__var_1153) && encdec_bop_backwards_matches(mapping7_hashtag__var_1152))) && (v__1559.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1100011)))} => {let imm7_6: BitVector<1> = v__1559.subrange::<31, 32, 1>();
                    let mapping7_hashtag_: BitVector<3> = v__1559.subrange::<12, 15, 3>();
                    let mapping6_hashtag_: BitVector<5> = v__1559.subrange::<15, 20, 5>();
                    let mapping5_hashtag_: BitVector<5> = v__1559.subrange::<20, 25, 5>();
                    let imm7_6: BitVector<1> = v__1559.subrange::<31, 32, 1>();
                    let imm7_5_0: BitVector<6> = v__1559.subrange::<25, 31, 6>();
                    let imm5_4_1: BitVector<4> = v__1559.subrange::<8, 12, 4>();
                    let imm5_0: BitVector<1> = v__1559.subrange::<7, 8, 1>();
                    match (encdec_reg_backwards(mapping5_hashtag_), encdec_reg_backwards(mapping6_hashtag_), encdec_bop_backwards(mapping7_hashtag_)) {
                        (rs2, rs1, op) => {Some(ast::BTYPE((bitvector_concat::<1, 12, 13>((imm7_6 as BitVector<1>), bitvector_concat::<1, 11, 12>((imm5_0 as BitVector<1>), bitvector_concat::<6, 5, 11>((imm7_5_0 as BitVector<6>), bitvector_concat::<4, 1, 5>((imm5_4_1 as BitVector<4>), BitVector::<1>::new(0b0))))), rs2, rs1, op)))}
                        _ => {None}
                        _ => {panic!("Unreachable code")}
                    }}
                    _ => {None}
                    _ => {panic!("Unreachable code")}
                } {
                    Some(result) => {result}
                    None => {match match head_exp_hashtag_ {
                        v__1557 if {let mapping9_hashtag__var_1149: BitVector<3> = v__1557.subrange::<12, 15, 3>();
                        let mapping8_hashtag__var_1150: BitVector<5> = v__1557.subrange::<15, 20, 5>();
                        let mapping10_hashtag__var_1151: BitVector<5> = v__1557.subrange::<7, 12, 5>();
                        ((encdec_reg_backwards_matches(mapping8_hashtag__var_1150) && (encdec_iop_backwards_matches(mapping9_hashtag__var_1149) && encdec_reg_backwards_matches(mapping10_hashtag__var_1151))) && (v__1557.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))} => {let imm: BitVector<12> = v__1557.subrange::<20, 32, 12>();
                        let mapping9_hashtag_: BitVector<3> = v__1557.subrange::<12, 15, 3>();
                        let mapping8_hashtag_: BitVector<5> = v__1557.subrange::<15, 20, 5>();
                        let mapping10_hashtag_: BitVector<5> = v__1557.subrange::<7, 12, 5>();
                        let imm: BitVector<12> = v__1557.subrange::<20, 32, 12>();
                        match (encdec_reg_backwards(mapping8_hashtag_), encdec_iop_backwards(mapping9_hashtag_), encdec_reg_backwards(mapping10_hashtag_)) {
                            (rs1, op, rd) => {Some(ast::ITYPE((imm, rs1, rd, op)))}
                            _ => {None}
                            _ => {panic!("Unreachable code")}
                        }}
                        _ => {None}
                        _ => {panic!("Unreachable code")}
                    } {
                        Some(result) => {result}
                        None => {match match head_exp_hashtag_ {
                            v__1553 if {let mapping12_hashtag__var_1147: BitVector<5> = v__1553.subrange::<7, 12, 5>();
                            let mapping11_hashtag__var_1148: BitVector<5> = v__1553.subrange::<15, 20, 5>();
                            ((encdec_reg_backwards_matches(mapping11_hashtag__var_1148) && encdec_reg_backwards_matches(mapping12_hashtag__var_1147)) && ((v__1553.subrange::<26, 32, 6>() == BitVector::<6>::new(0b000000)) && ((v__1553.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1553.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__1553.subrange::<20, 26, 6>();
                            let mapping12_hashtag_: BitVector<5> = v__1553.subrange::<7, 12, 5>();
                            let mapping11_hashtag_: BitVector<5> = v__1553.subrange::<15, 20, 5>();
                            match (encdec_reg_backwards(mapping11_hashtag_), encdec_reg_backwards(mapping12_hashtag_)) {
                                (rs1, rd) if {true} => {Some(ast::SHIFTIOP((shamt, rs1, rd, sop::SLLI)))}
                                _ => {None}
                                _ => {panic!("Unreachable code")}
                            }}
                            _ => {None}
                            _ => {panic!("Unreachable code")}
                        } {
                            Some(result) => {result}
                            None => {match match head_exp_hashtag_ {
                                v__1549 if {let mapping14_hashtag__var_1145: BitVector<5> = v__1549.subrange::<7, 12, 5>();
                                let mapping13_hashtag__var_1146: BitVector<5> = v__1549.subrange::<15, 20, 5>();
                                ((encdec_reg_backwards_matches(mapping13_hashtag__var_1146) && encdec_reg_backwards_matches(mapping14_hashtag__var_1145)) && ((v__1549.subrange::<26, 32, 6>() == BitVector::<6>::new(0b000000)) && ((v__1549.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1549.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__1549.subrange::<20, 26, 6>();
                                let mapping14_hashtag_: BitVector<5> = v__1549.subrange::<7, 12, 5>();
                                let mapping13_hashtag_: BitVector<5> = v__1549.subrange::<15, 20, 5>();
                                match (encdec_reg_backwards(mapping13_hashtag_), encdec_reg_backwards(mapping14_hashtag_)) {
                                    (rs1, rd) if {true} => {Some(ast::SHIFTIOP((shamt, rs1, rd, sop::SRLI)))}
                                    _ => {None}
                                    _ => {panic!("Unreachable code")}
                                }}
                                _ => {None}
                                _ => {panic!("Unreachable code")}
                            } {
                                Some(result) => {result}
                                None => {match match head_exp_hashtag_ {
                                    v__1545 if {let mapping16_hashtag__var_1143: BitVector<5> = v__1545.subrange::<7, 12, 5>();
                                    let mapping15_hashtag__var_1144: BitVector<5> = v__1545.subrange::<15, 20, 5>();
                                    ((encdec_reg_backwards_matches(mapping15_hashtag__var_1144) && encdec_reg_backwards_matches(mapping16_hashtag__var_1143)) && ((v__1545.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010000)) && ((v__1545.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1545.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__1545.subrange::<20, 26, 6>();
                                    let mapping16_hashtag_: BitVector<5> = v__1545.subrange::<7, 12, 5>();
                                    let mapping15_hashtag_: BitVector<5> = v__1545.subrange::<15, 20, 5>();
                                    match (encdec_reg_backwards(mapping15_hashtag_), encdec_reg_backwards(mapping16_hashtag_)) {
                                        (rs1, rd) if {true} => {Some(ast::SHIFTIOP((shamt, rs1, rd, sop::SRAI)))}
                                        _ => {None}
                                        _ => {panic!("Unreachable code")}
                                    }}
                                    _ => {None}
                                    _ => {panic!("Unreachable code")}
                                } {
                                    Some(result) => {result}
                                    None => {match match head_exp_hashtag_ {
                                        v__1541 if {let mapping19_hashtag__var_1140: BitVector<5> = v__1541.subrange::<7, 12, 5>();
                                        let mapping18_hashtag__var_1141: BitVector<5> = v__1541.subrange::<15, 20, 5>();
                                        let mapping17_hashtag__var_1142: BitVector<5> = v__1541.subrange::<20, 25, 5>();
                                        ((encdec_reg_backwards_matches(mapping17_hashtag__var_1142) && (encdec_reg_backwards_matches(mapping18_hashtag__var_1141) && encdec_reg_backwards_matches(mapping19_hashtag__var_1140))) && ((v__1541.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1541.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1541.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping19_hashtag_: BitVector<5> = v__1541.subrange::<7, 12, 5>();
                                        let mapping18_hashtag_: BitVector<5> = v__1541.subrange::<15, 20, 5>();
                                        let mapping17_hashtag_: BitVector<5> = v__1541.subrange::<20, 25, 5>();
                                        match (encdec_reg_backwards(mapping17_hashtag_), encdec_reg_backwards(mapping18_hashtag_), encdec_reg_backwards(mapping19_hashtag_)) {
                                            (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::ADD)))}
                                            _ => {None}
                                            _ => {panic!("Unreachable code")}
                                        }}
                                        _ => {None}
                                        _ => {panic!("Unreachable code")}
                                    } {
                                        Some(result) => {result}
                                        None => {match match head_exp_hashtag_ {
                                            v__1537 if {let mapping22_hashtag__var_1137: BitVector<5> = v__1537.subrange::<7, 12, 5>();
                                            let mapping21_hashtag__var_1138: BitVector<5> = v__1537.subrange::<15, 20, 5>();
                                            let mapping20_hashtag__var_1139: BitVector<5> = v__1537.subrange::<20, 25, 5>();
                                            ((encdec_reg_backwards_matches(mapping20_hashtag__var_1139) && (encdec_reg_backwards_matches(mapping21_hashtag__var_1138) && encdec_reg_backwards_matches(mapping22_hashtag__var_1137))) && ((v__1537.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1537.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1537.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping22_hashtag_: BitVector<5> = v__1537.subrange::<7, 12, 5>();
                                            let mapping21_hashtag_: BitVector<5> = v__1537.subrange::<15, 20, 5>();
                                            let mapping20_hashtag_: BitVector<5> = v__1537.subrange::<20, 25, 5>();
                                            match (encdec_reg_backwards(mapping20_hashtag_), encdec_reg_backwards(mapping21_hashtag_), encdec_reg_backwards(mapping22_hashtag_)) {
                                                (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SLT)))}
                                                _ => {None}
                                                _ => {panic!("Unreachable code")}
                                            }}
                                            _ => {None}
                                            _ => {panic!("Unreachable code")}
                                        } {
                                            Some(result) => {result}
                                            None => {match match head_exp_hashtag_ {
                                                v__1533 if {let mapping25_hashtag__var_1134: BitVector<5> = v__1533.subrange::<7, 12, 5>();
                                                let mapping24_hashtag__var_1135: BitVector<5> = v__1533.subrange::<15, 20, 5>();
                                                let mapping23_hashtag__var_1136: BitVector<5> = v__1533.subrange::<20, 25, 5>();
                                                ((encdec_reg_backwards_matches(mapping23_hashtag__var_1136) && (encdec_reg_backwards_matches(mapping24_hashtag__var_1135) && encdec_reg_backwards_matches(mapping25_hashtag__var_1134))) && ((v__1533.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1533.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__1533.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping25_hashtag_: BitVector<5> = v__1533.subrange::<7, 12, 5>();
                                                let mapping24_hashtag_: BitVector<5> = v__1533.subrange::<15, 20, 5>();
                                                let mapping23_hashtag_: BitVector<5> = v__1533.subrange::<20, 25, 5>();
                                                match (encdec_reg_backwards(mapping23_hashtag_), encdec_reg_backwards(mapping24_hashtag_), encdec_reg_backwards(mapping25_hashtag_)) {
                                                    (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SLTU)))}
                                                    _ => {None}
                                                    _ => {panic!("Unreachable code")}
                                                }}
                                                _ => {None}
                                                _ => {panic!("Unreachable code")}
                                            } {
                                                Some(result) => {result}
                                                None => {match match head_exp_hashtag_ {
                                                    v__1529 if {let mapping28_hashtag__var_1131: BitVector<5> = v__1529.subrange::<7, 12, 5>();
                                                    let mapping27_hashtag__var_1132: BitVector<5> = v__1529.subrange::<15, 20, 5>();
                                                    let mapping26_hashtag__var_1133: BitVector<5> = v__1529.subrange::<20, 25, 5>();
                                                    ((encdec_reg_backwards_matches(mapping26_hashtag__var_1133) && (encdec_reg_backwards_matches(mapping27_hashtag__var_1132) && encdec_reg_backwards_matches(mapping28_hashtag__var_1131))) && ((v__1529.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1529.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__1529.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping28_hashtag_: BitVector<5> = v__1529.subrange::<7, 12, 5>();
                                                    let mapping27_hashtag_: BitVector<5> = v__1529.subrange::<15, 20, 5>();
                                                    let mapping26_hashtag_: BitVector<5> = v__1529.subrange::<20, 25, 5>();
                                                    match (encdec_reg_backwards(mapping26_hashtag_), encdec_reg_backwards(mapping27_hashtag_), encdec_reg_backwards(mapping28_hashtag_)) {
                                                        (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::AND)))}
                                                        _ => {None}
                                                        _ => {panic!("Unreachable code")}
                                                    }}
                                                    _ => {None}
                                                    _ => {panic!("Unreachable code")}
                                                } {
                                                    Some(result) => {result}
                                                    None => {match match head_exp_hashtag_ {
                                                        v__1525 if {let mapping31_hashtag__var_1128: BitVector<5> = v__1525.subrange::<7, 12, 5>();
                                                        let mapping30_hashtag__var_1129: BitVector<5> = v__1525.subrange::<15, 20, 5>();
                                                        let mapping29_hashtag__var_1130: BitVector<5> = v__1525.subrange::<20, 25, 5>();
                                                        ((encdec_reg_backwards_matches(mapping29_hashtag__var_1130) && (encdec_reg_backwards_matches(mapping30_hashtag__var_1129) && encdec_reg_backwards_matches(mapping31_hashtag__var_1128))) && ((v__1525.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1525.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__1525.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping31_hashtag_: BitVector<5> = v__1525.subrange::<7, 12, 5>();
                                                        let mapping30_hashtag_: BitVector<5> = v__1525.subrange::<15, 20, 5>();
                                                        let mapping29_hashtag_: BitVector<5> = v__1525.subrange::<20, 25, 5>();
                                                        match (encdec_reg_backwards(mapping29_hashtag_), encdec_reg_backwards(mapping30_hashtag_), encdec_reg_backwards(mapping31_hashtag_)) {
                                                            (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::OR)))}
                                                            _ => {None}
                                                            _ => {panic!("Unreachable code")}
                                                        }}
                                                        _ => {None}
                                                        _ => {panic!("Unreachable code")}
                                                    } {
                                                        Some(result) => {result}
                                                        None => {match match head_exp_hashtag_ {
                                                            v__1521 if {let mapping34_hashtag__var_1125: BitVector<5> = v__1521.subrange::<7, 12, 5>();
                                                            let mapping33_hashtag__var_1126: BitVector<5> = v__1521.subrange::<15, 20, 5>();
                                                            let mapping32_hashtag__var_1127: BitVector<5> = v__1521.subrange::<20, 25, 5>();
                                                            ((encdec_reg_backwards_matches(mapping32_hashtag__var_1127) && (encdec_reg_backwards_matches(mapping33_hashtag__var_1126) && encdec_reg_backwards_matches(mapping34_hashtag__var_1125))) && ((v__1521.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1521.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1521.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping34_hashtag_: BitVector<5> = v__1521.subrange::<7, 12, 5>();
                                                            let mapping33_hashtag_: BitVector<5> = v__1521.subrange::<15, 20, 5>();
                                                            let mapping32_hashtag_: BitVector<5> = v__1521.subrange::<20, 25, 5>();
                                                            match (encdec_reg_backwards(mapping32_hashtag_), encdec_reg_backwards(mapping33_hashtag_), encdec_reg_backwards(mapping34_hashtag_)) {
                                                                (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::XOR)))}
                                                                _ => {None}
                                                                _ => {panic!("Unreachable code")}
                                                            }}
                                                            _ => {None}
                                                            _ => {panic!("Unreachable code")}
                                                        } {
                                                            Some(result) => {result}
                                                            None => {match match head_exp_hashtag_ {
                                                                v__1517 if {let mapping37_hashtag__var_1122: BitVector<5> = v__1517.subrange::<7, 12, 5>();
                                                                let mapping36_hashtag__var_1123: BitVector<5> = v__1517.subrange::<15, 20, 5>();
                                                                let mapping35_hashtag__var_1124: BitVector<5> = v__1517.subrange::<20, 25, 5>();
                                                                ((encdec_reg_backwards_matches(mapping35_hashtag__var_1124) && (encdec_reg_backwards_matches(mapping36_hashtag__var_1123) && encdec_reg_backwards_matches(mapping37_hashtag__var_1122))) && ((v__1517.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1517.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1517.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping37_hashtag_: BitVector<5> = v__1517.subrange::<7, 12, 5>();
                                                                let mapping36_hashtag_: BitVector<5> = v__1517.subrange::<15, 20, 5>();
                                                                let mapping35_hashtag_: BitVector<5> = v__1517.subrange::<20, 25, 5>();
                                                                match (encdec_reg_backwards(mapping35_hashtag_), encdec_reg_backwards(mapping36_hashtag_), encdec_reg_backwards(mapping37_hashtag_)) {
                                                                    (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SLL)))}
                                                                    _ => {None}
                                                                    _ => {panic!("Unreachable code")}
                                                                }}
                                                                _ => {None}
                                                                _ => {panic!("Unreachable code")}
                                                            } {
                                                                Some(result) => {result}
                                                                None => {match match head_exp_hashtag_ {
                                                                    v__1513 if {let mapping40_hashtag__var_1119: BitVector<5> = v__1513.subrange::<7, 12, 5>();
                                                                    let mapping39_hashtag__var_1120: BitVector<5> = v__1513.subrange::<15, 20, 5>();
                                                                    let mapping38_hashtag__var_1121: BitVector<5> = v__1513.subrange::<20, 25, 5>();
                                                                    ((encdec_reg_backwards_matches(mapping38_hashtag__var_1121) && (encdec_reg_backwards_matches(mapping39_hashtag__var_1120) && encdec_reg_backwards_matches(mapping40_hashtag__var_1119))) && ((v__1513.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1513.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1513.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping40_hashtag_: BitVector<5> = v__1513.subrange::<7, 12, 5>();
                                                                    let mapping39_hashtag_: BitVector<5> = v__1513.subrange::<15, 20, 5>();
                                                                    let mapping38_hashtag_: BitVector<5> = v__1513.subrange::<20, 25, 5>();
                                                                    match (encdec_reg_backwards(mapping38_hashtag_), encdec_reg_backwards(mapping39_hashtag_), encdec_reg_backwards(mapping40_hashtag_)) {
                                                                        (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SRL)))}
                                                                        _ => {None}
                                                                        _ => {panic!("Unreachable code")}
                                                                    }}
                                                                    _ => {None}
                                                                    _ => {panic!("Unreachable code")}
                                                                } {
                                                                    Some(result) => {result}
                                                                    None => {match match head_exp_hashtag_ {
                                                                        v__1509 if {let mapping43_hashtag__var_1116: BitVector<5> = v__1509.subrange::<7, 12, 5>();
                                                                        let mapping42_hashtag__var_1117: BitVector<5> = v__1509.subrange::<15, 20, 5>();
                                                                        let mapping41_hashtag__var_1118: BitVector<5> = v__1509.subrange::<20, 25, 5>();
                                                                        ((encdec_reg_backwards_matches(mapping41_hashtag__var_1118) && (encdec_reg_backwards_matches(mapping42_hashtag__var_1117) && encdec_reg_backwards_matches(mapping43_hashtag__var_1116))) && ((v__1509.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1509.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1509.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping43_hashtag_: BitVector<5> = v__1509.subrange::<7, 12, 5>();
                                                                        let mapping42_hashtag_: BitVector<5> = v__1509.subrange::<15, 20, 5>();
                                                                        let mapping41_hashtag_: BitVector<5> = v__1509.subrange::<20, 25, 5>();
                                                                        match (encdec_reg_backwards(mapping41_hashtag_), encdec_reg_backwards(mapping42_hashtag_), encdec_reg_backwards(mapping43_hashtag_)) {
                                                                            (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SUB)))}
                                                                            _ => {None}
                                                                            _ => {panic!("Unreachable code")}
                                                                        }}
                                                                        _ => {None}
                                                                        _ => {panic!("Unreachable code")}
                                                                    } {
                                                                        Some(result) => {result}
                                                                        None => {match match head_exp_hashtag_ {
                                                                            v__1505 if {let mapping46_hashtag__var_1113: BitVector<5> = v__1505.subrange::<7, 12, 5>();
                                                                            let mapping45_hashtag__var_1114: BitVector<5> = v__1505.subrange::<15, 20, 5>();
                                                                            let mapping44_hashtag__var_1115: BitVector<5> = v__1505.subrange::<20, 25, 5>();
                                                                            ((encdec_reg_backwards_matches(mapping44_hashtag__var_1115) && (encdec_reg_backwards_matches(mapping45_hashtag__var_1114) && encdec_reg_backwards_matches(mapping46_hashtag__var_1113))) && ((v__1505.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1505.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1505.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping46_hashtag_: BitVector<5> = v__1505.subrange::<7, 12, 5>();
                                                                            let mapping45_hashtag_: BitVector<5> = v__1505.subrange::<15, 20, 5>();
                                                                            let mapping44_hashtag_: BitVector<5> = v__1505.subrange::<20, 25, 5>();
                                                                            match (encdec_reg_backwards(mapping44_hashtag_), encdec_reg_backwards(mapping45_hashtag_), encdec_reg_backwards(mapping46_hashtag_)) {
                                                                                (rs2, rs1, rd) => {Some(ast::RTYPE((rs2, rs1, rd, rop::SRA)))}
                                                                                _ => {None}
                                                                                _ => {panic!("Unreachable code")}
                                                                            }}
                                                                            _ => {None}
                                                                            _ => {panic!("Unreachable code")}
                                                                        } {
                                                                            Some(result) => {result}
                                                                            None => {match match head_exp_hashtag_ {
                                                                                v__1503 if {let mapping50_hashtag__var_1109: BitVector<5> = v__1503.subrange::<7, 12, 5>();
                                                                                let mapping49_hashtag__var_1110: BitVector<2> = v__1503.subrange::<12, 14, 2>();
                                                                                let mapping48_hashtag__var_1111: BitVector<1> = v__1503.subrange::<14, 15, 1>();
                                                                                let mapping47_hashtag__var_1112: BitVector<5> = v__1503.subrange::<15, 20, 5>();
                                                                                ((encdec_reg_backwards_matches(mapping47_hashtag__var_1112) && (bool_bits_backwards_matches(mapping48_hashtag__var_1111) && (size_enc_backwards_matches(mapping49_hashtag__var_1110) && encdec_reg_backwards_matches(mapping50_hashtag__var_1109)))) && (v__1503.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000011)))} => {let imm: BitVector<12> = v__1503.subrange::<20, 32, 12>();
                                                                                let mapping50_hashtag_: BitVector<5> = v__1503.subrange::<7, 12, 5>();
                                                                                let mapping49_hashtag_: BitVector<2> = v__1503.subrange::<12, 14, 2>();
                                                                                let mapping48_hashtag_: BitVector<1> = v__1503.subrange::<14, 15, 1>();
                                                                                let mapping47_hashtag_: BitVector<5> = v__1503.subrange::<15, 20, 5>();
                                                                                let imm: BitVector<12> = v__1503.subrange::<20, 32, 12>();
                                                                                match (encdec_reg_backwards(mapping47_hashtag_), bool_bits_backwards(mapping48_hashtag_), size_enc_backwards(mapping49_hashtag_), encdec_reg_backwards(mapping50_hashtag_)) {
                                                                                    (rs1, is_unsigned, width, rd) if {valid_load_encdec(width, is_unsigned)} => {Some(ast::LOAD((imm, rs1, rd, is_unsigned, width, false, false)))}
                                                                                    _ => {None}
                                                                                    _ => {panic!("Unreachable code")}
                                                                                }}
                                                                                _ => {None}
                                                                                _ => {panic!("Unreachable code")}
                                                                            } {
                                                                                Some(result) => {result}
                                                                                None => {match match head_exp_hashtag_ {
                                                                                    v__1500 if {let mapping53_hashtag__var_1106: BitVector<2> = v__1500.subrange::<12, 14, 2>();
                                                                                    let mapping52_hashtag__var_1107: BitVector<5> = v__1500.subrange::<15, 20, 5>();
                                                                                    let mapping51_hashtag__var_1108: BitVector<5> = v__1500.subrange::<20, 25, 5>();
                                                                                    ((encdec_reg_backwards_matches(mapping51_hashtag__var_1108) && (encdec_reg_backwards_matches(mapping52_hashtag__var_1107) && size_enc_backwards_matches(mapping53_hashtag__var_1106))) && ((v__1500.subrange::<14, 15, 1>() == BitVector::<1>::new(0b0)) && (v__1500.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100011))))} => {let imm7: BitVector<7> = v__1500.subrange::<25, 32, 7>();
                                                                                    let mapping53_hashtag_: BitVector<2> = v__1500.subrange::<12, 14, 2>();
                                                                                    let mapping52_hashtag_: BitVector<5> = v__1500.subrange::<15, 20, 5>();
                                                                                    let mapping51_hashtag_: BitVector<5> = v__1500.subrange::<20, 25, 5>();
                                                                                    let imm7: BitVector<7> = v__1500.subrange::<25, 32, 7>();
                                                                                    let imm5: BitVector<5> = v__1500.subrange::<7, 12, 5>();
                                                                                    match (encdec_reg_backwards(mapping51_hashtag_), encdec_reg_backwards(mapping52_hashtag_), size_enc_backwards(mapping53_hashtag_)) {
                                                                                        (rs2, rs1, width) if {(size_bytes_forwards(width) <= 8)} => {Some(ast::STORE((bitvector_concat::<7, 5, 12>((imm7 as BitVector<7>), (imm5 as BitVector<5>)), rs2, rs1, width, false, false)))}
                                                                                        _ => {None}
                                                                                        _ => {panic!("Unreachable code")}
                                                                                    }}
                                                                                    _ => {None}
                                                                                    _ => {panic!("Unreachable code")}
                                                                                } {
                                                                                    Some(result) => {result}
                                                                                    None => {match match head_exp_hashtag_ {
                                                                                        v__1497 if {let mapping55_hashtag__var_1104: BitVector<5> = v__1497.subrange::<7, 12, 5>();
                                                                                        let mapping54_hashtag__var_1105: BitVector<5> = v__1497.subrange::<15, 20, 5>();
                                                                                        ((encdec_reg_backwards_matches(mapping54_hashtag__var_1105) && encdec_reg_backwards_matches(mapping55_hashtag__var_1104)) && ((v__1497.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1497.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011))))} => {let imm: BitVector<12> = v__1497.subrange::<20, 32, 12>();
                                                                                        let mapping55_hashtag_: BitVector<5> = v__1497.subrange::<7, 12, 5>();
                                                                                        let mapping54_hashtag_: BitVector<5> = v__1497.subrange::<15, 20, 5>();
                                                                                        let imm: BitVector<12> = v__1497.subrange::<20, 32, 12>();
                                                                                        match (encdec_reg_backwards(mapping54_hashtag_), encdec_reg_backwards(mapping55_hashtag_)) {
                                                                                            (rs1, rd) if {true} => {Some(ast::ADDIW((imm, rs1, rd)))}
                                                                                            _ => {None}
                                                                                            _ => {panic!("Unreachable code")}
                                                                                        }}
                                                                                        _ => {None}
                                                                                        _ => {panic!("Unreachable code")}
                                                                                    } {
                                                                                        Some(result) => {result}
                                                                                        None => {match match head_exp_hashtag_ {
                                                                                            v__1493 if {let mapping58_hashtag__var_1101: BitVector<5> = v__1493.subrange::<7, 12, 5>();
                                                                                            let mapping57_hashtag__var_1102: BitVector<5> = v__1493.subrange::<15, 20, 5>();
                                                                                            let mapping56_hashtag__var_1103: BitVector<5> = v__1493.subrange::<20, 25, 5>();
                                                                                            ((encdec_reg_backwards_matches(mapping56_hashtag__var_1103) && (encdec_reg_backwards_matches(mapping57_hashtag__var_1102) && encdec_reg_backwards_matches(mapping58_hashtag__var_1101))) && ((v__1493.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1493.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1493.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping58_hashtag_: BitVector<5> = v__1493.subrange::<7, 12, 5>();
                                                                                            let mapping57_hashtag_: BitVector<5> = v__1493.subrange::<15, 20, 5>();
                                                                                            let mapping56_hashtag_: BitVector<5> = v__1493.subrange::<20, 25, 5>();
                                                                                            match (encdec_reg_backwards(mapping56_hashtag_), encdec_reg_backwards(mapping57_hashtag_), encdec_reg_backwards(mapping58_hashtag_)) {
                                                                                                (rs2, rs1, rd) if {true} => {Some(ast::RTYPEW((rs2, rs1, rd, ropw::ADDW)))}
                                                                                                _ => {None}
                                                                                                _ => {panic!("Unreachable code")}
                                                                                            }}
                                                                                            _ => {None}
                                                                                            _ => {panic!("Unreachable code")}
                                                                                        } {
                                                                                            Some(result) => {result}
                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                v__1489 if {let mapping61_hashtag__var_1098: BitVector<5> = v__1489.subrange::<7, 12, 5>();
                                                                                                let mapping60_hashtag__var_1099: BitVector<5> = v__1489.subrange::<15, 20, 5>();
                                                                                                let mapping59_hashtag__var_1100: BitVector<5> = v__1489.subrange::<20, 25, 5>();
                                                                                                ((encdec_reg_backwards_matches(mapping59_hashtag__var_1100) && (encdec_reg_backwards_matches(mapping60_hashtag__var_1099) && encdec_reg_backwards_matches(mapping61_hashtag__var_1098))) && ((v__1489.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1489.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1489.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping61_hashtag_: BitVector<5> = v__1489.subrange::<7, 12, 5>();
                                                                                                let mapping60_hashtag_: BitVector<5> = v__1489.subrange::<15, 20, 5>();
                                                                                                let mapping59_hashtag_: BitVector<5> = v__1489.subrange::<20, 25, 5>();
                                                                                                match (encdec_reg_backwards(mapping59_hashtag_), encdec_reg_backwards(mapping60_hashtag_), encdec_reg_backwards(mapping61_hashtag_)) {
                                                                                                    (rs2, rs1, rd) if {true} => {Some(ast::RTYPEW((rs2, rs1, rd, ropw::SUBW)))}
                                                                                                    _ => {None}
                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                }}
                                                                                                _ => {None}
                                                                                                _ => {panic!("Unreachable code")}
                                                                                            } {
                                                                                                Some(result) => {result}
                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                    v__1485 if {let mapping64_hashtag__var_1095: BitVector<5> = v__1485.subrange::<7, 12, 5>();
                                                                                                    let mapping63_hashtag__var_1096: BitVector<5> = v__1485.subrange::<15, 20, 5>();
                                                                                                    let mapping62_hashtag__var_1097: BitVector<5> = v__1485.subrange::<20, 25, 5>();
                                                                                                    ((encdec_reg_backwards_matches(mapping62_hashtag__var_1097) && (encdec_reg_backwards_matches(mapping63_hashtag__var_1096) && encdec_reg_backwards_matches(mapping64_hashtag__var_1095))) && ((v__1485.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1485.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1485.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping64_hashtag_: BitVector<5> = v__1485.subrange::<7, 12, 5>();
                                                                                                    let mapping63_hashtag_: BitVector<5> = v__1485.subrange::<15, 20, 5>();
                                                                                                    let mapping62_hashtag_: BitVector<5> = v__1485.subrange::<20, 25, 5>();
                                                                                                    match (encdec_reg_backwards(mapping62_hashtag_), encdec_reg_backwards(mapping63_hashtag_), encdec_reg_backwards(mapping64_hashtag_)) {
                                                                                                        (rs2, rs1, rd) if {true} => {Some(ast::RTYPEW((rs2, rs1, rd, ropw::SLLW)))}
                                                                                                        _ => {None}
                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                    }}
                                                                                                    _ => {None}
                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                } {
                                                                                                    Some(result) => {result}
                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                        v__1481 if {let mapping67_hashtag__var_1092: BitVector<5> = v__1481.subrange::<7, 12, 5>();
                                                                                                        let mapping66_hashtag__var_1093: BitVector<5> = v__1481.subrange::<15, 20, 5>();
                                                                                                        let mapping65_hashtag__var_1094: BitVector<5> = v__1481.subrange::<20, 25, 5>();
                                                                                                        ((encdec_reg_backwards_matches(mapping65_hashtag__var_1094) && (encdec_reg_backwards_matches(mapping66_hashtag__var_1093) && encdec_reg_backwards_matches(mapping67_hashtag__var_1092))) && ((v__1481.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1481.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1481.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping67_hashtag_: BitVector<5> = v__1481.subrange::<7, 12, 5>();
                                                                                                        let mapping66_hashtag_: BitVector<5> = v__1481.subrange::<15, 20, 5>();
                                                                                                        let mapping65_hashtag_: BitVector<5> = v__1481.subrange::<20, 25, 5>();
                                                                                                        match (encdec_reg_backwards(mapping65_hashtag_), encdec_reg_backwards(mapping66_hashtag_), encdec_reg_backwards(mapping67_hashtag_)) {
                                                                                                            (rs2, rs1, rd) if {true} => {Some(ast::RTYPEW((rs2, rs1, rd, ropw::SRLW)))}
                                                                                                            _ => {None}
                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                        }}
                                                                                                        _ => {None}
                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                    } {
                                                                                                        Some(result) => {result}
                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                            v__1477 if {let mapping70_hashtag__var_1089: BitVector<5> = v__1477.subrange::<7, 12, 5>();
                                                                                                            let mapping69_hashtag__var_1090: BitVector<5> = v__1477.subrange::<15, 20, 5>();
                                                                                                            let mapping68_hashtag__var_1091: BitVector<5> = v__1477.subrange::<20, 25, 5>();
                                                                                                            ((encdec_reg_backwards_matches(mapping68_hashtag__var_1091) && (encdec_reg_backwards_matches(mapping69_hashtag__var_1090) && encdec_reg_backwards_matches(mapping70_hashtag__var_1089))) && ((v__1477.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1477.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1477.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping70_hashtag_: BitVector<5> = v__1477.subrange::<7, 12, 5>();
                                                                                                            let mapping69_hashtag_: BitVector<5> = v__1477.subrange::<15, 20, 5>();
                                                                                                            let mapping68_hashtag_: BitVector<5> = v__1477.subrange::<20, 25, 5>();
                                                                                                            match (encdec_reg_backwards(mapping68_hashtag_), encdec_reg_backwards(mapping69_hashtag_), encdec_reg_backwards(mapping70_hashtag_)) {
                                                                                                                (rs2, rs1, rd) if {true} => {Some(ast::RTYPEW((rs2, rs1, rd, ropw::SRAW)))}
                                                                                                                _ => {None}
                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                            }}
                                                                                                            _ => {None}
                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                        } {
                                                                                                            Some(result) => {result}
                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                v__1473 if {let mapping72_hashtag__var_1087: BitVector<5> = v__1473.subrange::<7, 12, 5>();
                                                                                                                let mapping71_hashtag__var_1088: BitVector<5> = v__1473.subrange::<15, 20, 5>();
                                                                                                                ((encdec_reg_backwards_matches(mapping71_hashtag__var_1088) && encdec_reg_backwards_matches(mapping72_hashtag__var_1087)) && ((v__1473.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1473.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1473.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let shamt: BitVector<5> = v__1473.subrange::<20, 25, 5>();
                                                                                                                let mapping72_hashtag_: BitVector<5> = v__1473.subrange::<7, 12, 5>();
                                                                                                                let mapping71_hashtag_: BitVector<5> = v__1473.subrange::<15, 20, 5>();
                                                                                                                match (encdec_reg_backwards(mapping71_hashtag_), encdec_reg_backwards(mapping72_hashtag_)) {
                                                                                                                    (rs1, rd) if {true} => {Some(ast::SHIFTIWOP((shamt, rs1, rd, sopw::SLLIW)))}
                                                                                                                    _ => {None}
                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                }}
                                                                                                                _ => {None}
                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                            } {
                                                                                                                Some(result) => {result}
                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                    v__1469 if {let mapping74_hashtag__var_1085: BitVector<5> = v__1469.subrange::<7, 12, 5>();
                                                                                                                    let mapping73_hashtag__var_1086: BitVector<5> = v__1469.subrange::<15, 20, 5>();
                                                                                                                    ((encdec_reg_backwards_matches(mapping73_hashtag__var_1086) && encdec_reg_backwards_matches(mapping74_hashtag__var_1085)) && ((v__1469.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && ((v__1469.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1469.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let shamt: BitVector<5> = v__1469.subrange::<20, 25, 5>();
                                                                                                                    let mapping74_hashtag_: BitVector<5> = v__1469.subrange::<7, 12, 5>();
                                                                                                                    let mapping73_hashtag_: BitVector<5> = v__1469.subrange::<15, 20, 5>();
                                                                                                                    match (encdec_reg_backwards(mapping73_hashtag_), encdec_reg_backwards(mapping74_hashtag_)) {
                                                                                                                        (rs1, rd) if {true} => {Some(ast::SHIFTIWOP((shamt, rs1, rd, sopw::SRLIW)))}
                                                                                                                        _ => {None}
                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                    }}
                                                                                                                    _ => {None}
                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                } {
                                                                                                                    Some(result) => {result}
                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                        v__1465 if {let mapping76_hashtag__var_1083: BitVector<5> = v__1465.subrange::<7, 12, 5>();
                                                                                                                        let mapping75_hashtag__var_1084: BitVector<5> = v__1465.subrange::<15, 20, 5>();
                                                                                                                        ((encdec_reg_backwards_matches(mapping75_hashtag__var_1084) && encdec_reg_backwards_matches(mapping76_hashtag__var_1083)) && ((v__1465.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1465.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1465.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let shamt: BitVector<5> = v__1465.subrange::<20, 25, 5>();
                                                                                                                        let mapping76_hashtag_: BitVector<5> = v__1465.subrange::<7, 12, 5>();
                                                                                                                        let mapping75_hashtag_: BitVector<5> = v__1465.subrange::<15, 20, 5>();
                                                                                                                        match (encdec_reg_backwards(mapping75_hashtag_), encdec_reg_backwards(mapping76_hashtag_)) {
                                                                                                                            (rs1, rd) if {true} => {Some(ast::SHIFTIWOP((shamt, rs1, rd, sopw::SRAIW)))}
                                                                                                                            _ => {None}
                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                        }}
                                                                                                                        _ => {None}
                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                    } {
                                                                                                                        Some(result) => {result}
                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                            v__1416 if {((v__1416.subrange::<28, 32, 4>() == BitVector::<4>::new(0b0000)) && (v__1416.subrange::<0, 20, 20>() == BitVector::<20>::new(0b00000000000000001111)))} => {let succ: BitVector<4> = v__1416.subrange::<20, 24, 4>();
                                                                                                                            let pred: BitVector<4> = v__1416.subrange::<24, 28, 4>();
                                                                                                                            Some(ast::FENCE((pred, succ)))}
                                                                                                                            v__1422 if {((v__1422.subrange::<28, 32, 4>() == BitVector::<4>::new(0b1000)) && (v__1422.subrange::<0, 20, 20>() == BitVector::<20>::new(0b00000000000000001111)))} => {let succ: BitVector<4> = v__1422.subrange::<20, 24, 4>();
                                                                                                                            let pred: BitVector<4> = v__1422.subrange::<24, 28, 4>();
                                                                                                                            Some(ast::FENCE_TSO((pred, succ)))}
                                                                                                                            v__1428 if {(v__1428 == BitVector::<32>::new(0b00000000000000000000000001110011))} => {Some(ast::ECALL(()))}
                                                                                                                            v__1434 if {(v__1434 == BitVector::<32>::new(0b00110000001000000000000001110011))} => {Some(ast::MRET(()))}
                                                                                                                            v__1441 if {(v__1441 == BitVector::<32>::new(0b00010000001000000000000001110011))} => {Some(ast::SRET(()))}
                                                                                                                            v__1448 if {(v__1448 == BitVector::<32>::new(0b00000000000100000000000001110011))} => {Some(ast::EBREAK(()))}
                                                                                                                            v__1454 if {(v__1454 == BitVector::<32>::new(0b00010000010100000000000001110011))} => {Some(ast::WFI(()))}
                                                                                                                            v__1460 if {let mapping78_hashtag__var_1081: BitVector<5> = v__1460.subrange::<15, 20, 5>();
                                                                                                                            let mapping77_hashtag__var_1082: BitVector<5> = v__1460.subrange::<20, 25, 5>();
                                                                                                                            ((encdec_reg_backwards_matches(mapping77_hashtag__var_1082) && encdec_reg_backwards_matches(mapping78_hashtag__var_1081)) && ((v__1460.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001001)) && (v__1460.subrange::<0, 15, 15>() == BitVector::<15>::new(0b000000001110011))))} => {let mapping78_hashtag_: BitVector<5> = v__1460.subrange::<15, 20, 5>();
                                                                                                                            let mapping77_hashtag_: BitVector<5> = v__1460.subrange::<20, 25, 5>();
                                                                                                                            match (encdec_reg_backwards(mapping77_hashtag_), encdec_reg_backwards(mapping78_hashtag_)) {
                                                                                                                                (rs2, rs1) => {Some(ast::SFENCE_VMA((rs1, rs2)))}
                                                                                                                                _ => {None}
                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                            }}
                                                                                                                            _ => {None}
                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                        } {
                                                                                                                            Some(result) => {result}
                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                v__1405 if {(currentlyEnabled(core_ctx, extension::Ext_Zifencei) && (v__1405 == BitVector::<32>::new(0b00000000000000000001000000001111)))} => {Some(ast::FENCEI(()))}
                                                                                                                                v__1411 if {let mapping83_hashtag__var_1076: BitVector<5> = v__1411.subrange::<7, 12, 5>();
                                                                                                                                let mapping82_hashtag__var_1077: BitVector<2> = v__1411.subrange::<12, 14, 2>();
                                                                                                                                let mapping81_hashtag__var_1078: BitVector<5> = v__1411.subrange::<15, 20, 5>();
                                                                                                                                let mapping80_hashtag__var_1079: BitVector<1> = v__1411.subrange::<25, 26, 1>();
                                                                                                                                let mapping79_hashtag__var_1080: BitVector<1> = v__1411.subrange::<26, 27, 1>();
                                                                                                                                ((bool_bits_backwards_matches(mapping79_hashtag__var_1080) && (bool_bits_backwards_matches(mapping80_hashtag__var_1079) && (encdec_reg_backwards_matches(mapping81_hashtag__var_1078) && (size_enc_backwards_matches(mapping82_hashtag__var_1077) && encdec_reg_backwards_matches(mapping83_hashtag__var_1076))))) && ((v__1411.subrange::<27, 32, 5>() == BitVector::<5>::new(0b00010)) && ((v__1411.subrange::<20, 25, 5>() == BitVector::<5>::new(0b00000)) && ((v__1411.subrange::<14, 15, 1>() == BitVector::<1>::new(0b0)) && (v__1411.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0101111))))))} => {let mapping83_hashtag_: BitVector<5> = v__1411.subrange::<7, 12, 5>();
                                                                                                                                let mapping82_hashtag_: BitVector<2> = v__1411.subrange::<12, 14, 2>();
                                                                                                                                let mapping81_hashtag_: BitVector<5> = v__1411.subrange::<15, 20, 5>();
                                                                                                                                let mapping80_hashtag_: BitVector<1> = v__1411.subrange::<25, 26, 1>();
                                                                                                                                let mapping79_hashtag_: BitVector<1> = v__1411.subrange::<26, 27, 1>();
                                                                                                                                match (bool_bits_backwards(mapping79_hashtag_), bool_bits_backwards(mapping80_hashtag_), encdec_reg_backwards(mapping81_hashtag_), size_enc_backwards(mapping82_hashtag_), encdec_reg_backwards(mapping83_hashtag_)) {
                                                                                                                                    (aq, rl, rs1, size, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zalrsc) && lrsc_width_valid(size))} => {Some(ast::LOADRES((aq, rl, rs1, size, rd)))}
                                                                                                                                    _ => {None}
                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                }}
                                                                                                                                _ => {None}
                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                            } {
                                                                                                                                Some(result) => {result}
                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                    v__1401 if {let mapping89_hashtag__var_1070: BitVector<5> = v__1401.subrange::<7, 12, 5>();
                                                                                                                                    let mapping88_hashtag__var_1071: BitVector<2> = v__1401.subrange::<12, 14, 2>();
                                                                                                                                    let mapping87_hashtag__var_1072: BitVector<5> = v__1401.subrange::<15, 20, 5>();
                                                                                                                                    let mapping86_hashtag__var_1073: BitVector<5> = v__1401.subrange::<20, 25, 5>();
                                                                                                                                    let mapping85_hashtag__var_1074: BitVector<1> = v__1401.subrange::<25, 26, 1>();
                                                                                                                                    let mapping84_hashtag__var_1075: BitVector<1> = v__1401.subrange::<26, 27, 1>();
                                                                                                                                    ((bool_bits_backwards_matches(mapping84_hashtag__var_1075) && (bool_bits_backwards_matches(mapping85_hashtag__var_1074) && (encdec_reg_backwards_matches(mapping86_hashtag__var_1073) && (encdec_reg_backwards_matches(mapping87_hashtag__var_1072) && (size_enc_backwards_matches(mapping88_hashtag__var_1071) && encdec_reg_backwards_matches(mapping89_hashtag__var_1070)))))) && ((v__1401.subrange::<27, 32, 5>() == BitVector::<5>::new(0b00011)) && ((v__1401.subrange::<14, 15, 1>() == BitVector::<1>::new(0b0)) && (v__1401.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0101111)))))} => {let mapping89_hashtag_: BitVector<5> = v__1401.subrange::<7, 12, 5>();
                                                                                                                                    let mapping88_hashtag_: BitVector<2> = v__1401.subrange::<12, 14, 2>();
                                                                                                                                    let mapping87_hashtag_: BitVector<5> = v__1401.subrange::<15, 20, 5>();
                                                                                                                                    let mapping86_hashtag_: BitVector<5> = v__1401.subrange::<20, 25, 5>();
                                                                                                                                    let mapping85_hashtag_: BitVector<1> = v__1401.subrange::<25, 26, 1>();
                                                                                                                                    let mapping84_hashtag_: BitVector<1> = v__1401.subrange::<26, 27, 1>();
                                                                                                                                    match (bool_bits_backwards(mapping84_hashtag_), bool_bits_backwards(mapping85_hashtag_), encdec_reg_backwards(mapping86_hashtag_), encdec_reg_backwards(mapping87_hashtag_), size_enc_backwards(mapping88_hashtag_), encdec_reg_backwards(mapping89_hashtag_)) {
                                                                                                                                        (aq, rl, rs2, rs1, size, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zalrsc) && lrsc_width_valid(size))} => {Some(ast::STORECON((aq, rl, rs2, rs1, size, rd)))}
                                                                                                                                        _ => {None}
                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                    }}
                                                                                                                                    _ => {None}
                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                } {
                                                                                                                                    Some(result) => {result}
                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                        v__1398 if {let mapping90_hashtag__var_1062: BitVector<5> = v__1398.subrange::<27, 32, 5>();
                                                                                                                                        let mapping96_hashtag__var_1063: BitVector<5> = v__1398.subrange::<7, 12, 5>();
                                                                                                                                        let mapping95_hashtag__var_1064: BitVector<2> = v__1398.subrange::<12, 14, 2>();
                                                                                                                                        let mapping94_hashtag__var_1065: BitVector<5> = v__1398.subrange::<15, 20, 5>();
                                                                                                                                        let mapping93_hashtag__var_1066: BitVector<5> = v__1398.subrange::<20, 25, 5>();
                                                                                                                                        let mapping92_hashtag__var_1067: BitVector<1> = v__1398.subrange::<25, 26, 1>();
                                                                                                                                        let mapping91_hashtag__var_1068: BitVector<1> = v__1398.subrange::<26, 27, 1>();
                                                                                                                                        let mapping90_hashtag__var_1069: BitVector<5> = v__1398.subrange::<27, 32, 5>();
                                                                                                                                        ((encdec_amoop_backwards_matches(mapping90_hashtag__var_1069) && (bool_bits_backwards_matches(mapping91_hashtag__var_1068) && (bool_bits_backwards_matches(mapping92_hashtag__var_1067) && (encdec_reg_backwards_matches(mapping93_hashtag__var_1066) && (encdec_reg_backwards_matches(mapping94_hashtag__var_1065) && (size_enc_backwards_matches(mapping95_hashtag__var_1064) && encdec_reg_backwards_matches(mapping96_hashtag__var_1063))))))) && ((v__1398.subrange::<14, 15, 1>() == BitVector::<1>::new(0b0)) && (v__1398.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0101111))))} => {let mapping90_hashtag_: BitVector<5> = v__1398.subrange::<27, 32, 5>();
                                                                                                                                        let mapping96_hashtag_: BitVector<5> = v__1398.subrange::<7, 12, 5>();
                                                                                                                                        let mapping95_hashtag_: BitVector<2> = v__1398.subrange::<12, 14, 2>();
                                                                                                                                        let mapping94_hashtag_: BitVector<5> = v__1398.subrange::<15, 20, 5>();
                                                                                                                                        let mapping93_hashtag_: BitVector<5> = v__1398.subrange::<20, 25, 5>();
                                                                                                                                        let mapping92_hashtag_: BitVector<1> = v__1398.subrange::<25, 26, 1>();
                                                                                                                                        let mapping91_hashtag_: BitVector<1> = v__1398.subrange::<26, 27, 1>();
                                                                                                                                        let mapping90_hashtag_: BitVector<5> = v__1398.subrange::<27, 32, 5>();
                                                                                                                                        match (encdec_amoop_backwards(mapping90_hashtag_), bool_bits_backwards(mapping91_hashtag_), bool_bits_backwards(mapping92_hashtag_), encdec_reg_backwards(mapping93_hashtag_), encdec_reg_backwards(mapping94_hashtag_), size_enc_backwards(mapping95_hashtag_), encdec_reg_backwards(mapping96_hashtag_)) {
                                                                                                                                            (op, aq, rl, rs2, rs1, size, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zaamo) && amo_width_valid(core_ctx, size))} => {Some(ast::AMO((op, aq, rl, rs2, rs1, size, rd)))}
                                                                                                                                            _ => {None}
                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                        }}
                                                                                                                                        _ => {None}
                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                    } {
                                                                                                                                        Some(result) => {result}
                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                            v__1395 if {let mapping99_hashtag__var_1058: BitVector<3> = v__1395.subrange::<12, 15, 3>();
                                                                                                                                            let mapping98_hashtag__var_1059: BitVector<5> = v__1395.subrange::<15, 20, 5>();
                                                                                                                                            let mapping97_hashtag__var_1060: BitVector<5> = v__1395.subrange::<20, 25, 5>();
                                                                                                                                            let mapping100_hashtag__var_1061: BitVector<5> = v__1395.subrange::<7, 12, 5>();
                                                                                                                                            ((encdec_reg_backwards_matches(mapping97_hashtag__var_1060) && (encdec_reg_backwards_matches(mapping98_hashtag__var_1059) && (encdec_mul_op_backwards_matches(mapping99_hashtag__var_1058) && encdec_reg_backwards_matches(mapping100_hashtag__var_1061)))) && ((v__1395.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && (v__1395.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011))))} => {let mapping99_hashtag_: BitVector<3> = v__1395.subrange::<12, 15, 3>();
                                                                                                                                            let mapping98_hashtag_: BitVector<5> = v__1395.subrange::<15, 20, 5>();
                                                                                                                                            let mapping97_hashtag_: BitVector<5> = v__1395.subrange::<20, 25, 5>();
                                                                                                                                            let mapping100_hashtag_: BitVector<5> = v__1395.subrange::<7, 12, 5>();
                                                                                                                                            match (encdec_reg_backwards(mapping97_hashtag_), encdec_reg_backwards(mapping98_hashtag_), encdec_mul_op_backwards(mapping99_hashtag_), encdec_reg_backwards(mapping100_hashtag_)) {
                                                                                                                                                (rs2, rs1, mul_op, rd) if {(currentlyEnabled(core_ctx, extension::Ext_M) || currentlyEnabled(core_ctx, extension::Ext_Zmmul))} => {Some(ast::MUL((rs2, rs1, rd, mul_op)))}
                                                                                                                                                _ => {None}
                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                            }}
                                                                                                                                            _ => {None}
                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                        } {
                                                                                                                                            Some(result) => {result}
                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                v__1391 if {let mapping104_hashtag__var_1054: BitVector<5> = v__1391.subrange::<7, 12, 5>();
                                                                                                                                                let mapping103_hashtag__var_1055: BitVector<1> = v__1391.subrange::<12, 13, 1>();
                                                                                                                                                let mapping102_hashtag__var_1056: BitVector<5> = v__1391.subrange::<15, 20, 5>();
                                                                                                                                                let mapping101_hashtag__var_1057: BitVector<5> = v__1391.subrange::<20, 25, 5>();
                                                                                                                                                ((encdec_reg_backwards_matches(mapping101_hashtag__var_1057) && (encdec_reg_backwards_matches(mapping102_hashtag__var_1056) && (bool_not_bits_backwards_matches(mapping103_hashtag__var_1055) && encdec_reg_backwards_matches(mapping104_hashtag__var_1054)))) && ((v__1391.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && ((v__1391.subrange::<13, 15, 2>() == BitVector::<2>::new(0b10)) && (v__1391.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping104_hashtag_: BitVector<5> = v__1391.subrange::<7, 12, 5>();
                                                                                                                                                let mapping103_hashtag_: BitVector<1> = v__1391.subrange::<12, 13, 1>();
                                                                                                                                                let mapping102_hashtag_: BitVector<5> = v__1391.subrange::<15, 20, 5>();
                                                                                                                                                let mapping101_hashtag_: BitVector<5> = v__1391.subrange::<20, 25, 5>();
                                                                                                                                                match (encdec_reg_backwards(mapping101_hashtag_), encdec_reg_backwards(mapping102_hashtag_), bool_not_bits_backwards(mapping103_hashtag_), encdec_reg_backwards(mapping104_hashtag_)) {
                                                                                                                                                    (rs2, rs1, s, rd) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {Some(ast::DIV((rs2, rs1, rd, s)))}
                                                                                                                                                    _ => {None}
                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                }}
                                                                                                                                                _ => {None}
                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                            } {
                                                                                                                                                Some(result) => {result}
                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                    v__1387 if {let mapping108_hashtag__var_1050: BitVector<5> = v__1387.subrange::<7, 12, 5>();
                                                                                                                                                    let mapping107_hashtag__var_1051: BitVector<1> = v__1387.subrange::<12, 13, 1>();
                                                                                                                                                    let mapping106_hashtag__var_1052: BitVector<5> = v__1387.subrange::<15, 20, 5>();
                                                                                                                                                    let mapping105_hashtag__var_1053: BitVector<5> = v__1387.subrange::<20, 25, 5>();
                                                                                                                                                    ((encdec_reg_backwards_matches(mapping105_hashtag__var_1053) && (encdec_reg_backwards_matches(mapping106_hashtag__var_1052) && (bool_not_bits_backwards_matches(mapping107_hashtag__var_1051) && encdec_reg_backwards_matches(mapping108_hashtag__var_1050)))) && ((v__1387.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && ((v__1387.subrange::<13, 15, 2>() == BitVector::<2>::new(0b11)) && (v__1387.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping108_hashtag_: BitVector<5> = v__1387.subrange::<7, 12, 5>();
                                                                                                                                                    let mapping107_hashtag_: BitVector<1> = v__1387.subrange::<12, 13, 1>();
                                                                                                                                                    let mapping106_hashtag_: BitVector<5> = v__1387.subrange::<15, 20, 5>();
                                                                                                                                                    let mapping105_hashtag_: BitVector<5> = v__1387.subrange::<20, 25, 5>();
                                                                                                                                                    match (encdec_reg_backwards(mapping105_hashtag_), encdec_reg_backwards(mapping106_hashtag_), bool_not_bits_backwards(mapping107_hashtag_), encdec_reg_backwards(mapping108_hashtag_)) {
                                                                                                                                                        (rs2, rs1, s, rd) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {Some(ast::REM((rs2, rs1, rd, s)))}
                                                                                                                                                        _ => {None}
                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                    }}
                                                                                                                                                    _ => {None}
                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                } {
                                                                                                                                                    Some(result) => {result}
                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                        v__1383 if {let mapping111_hashtag__var_1047: BitVector<5> = v__1383.subrange::<7, 12, 5>();
                                                                                                                                                        let mapping110_hashtag__var_1048: BitVector<5> = v__1383.subrange::<15, 20, 5>();
                                                                                                                                                        let mapping109_hashtag__var_1049: BitVector<5> = v__1383.subrange::<20, 25, 5>();
                                                                                                                                                        ((encdec_reg_backwards_matches(mapping109_hashtag__var_1049) && (encdec_reg_backwards_matches(mapping110_hashtag__var_1048) && encdec_reg_backwards_matches(mapping111_hashtag__var_1047))) && ((v__1383.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && ((v__1383.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1383.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping111_hashtag_: BitVector<5> = v__1383.subrange::<7, 12, 5>();
                                                                                                                                                        let mapping110_hashtag_: BitVector<5> = v__1383.subrange::<15, 20, 5>();
                                                                                                                                                        let mapping109_hashtag_: BitVector<5> = v__1383.subrange::<20, 25, 5>();
                                                                                                                                                        match (encdec_reg_backwards(mapping109_hashtag_), encdec_reg_backwards(mapping110_hashtag_), encdec_reg_backwards(mapping111_hashtag_)) {
                                                                                                                                                            (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_M) || currentlyEnabled(core_ctx, extension::Ext_Zmmul))} => {Some(ast::MULW((rs2, rs1, rd)))}
                                                                                                                                                            _ => {None}
                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                        }}
                                                                                                                                                        _ => {None}
                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                    } {
                                                                                                                                                        Some(result) => {result}
                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                            v__1379 if {let mapping115_hashtag__var_1043: BitVector<5> = v__1379.subrange::<7, 12, 5>();
                                                                                                                                                            let mapping114_hashtag__var_1044: BitVector<1> = v__1379.subrange::<12, 13, 1>();
                                                                                                                                                            let mapping113_hashtag__var_1045: BitVector<5> = v__1379.subrange::<15, 20, 5>();
                                                                                                                                                            let mapping112_hashtag__var_1046: BitVector<5> = v__1379.subrange::<20, 25, 5>();
                                                                                                                                                            ((encdec_reg_backwards_matches(mapping112_hashtag__var_1046) && (encdec_reg_backwards_matches(mapping113_hashtag__var_1045) && (bool_not_bits_backwards_matches(mapping114_hashtag__var_1044) && encdec_reg_backwards_matches(mapping115_hashtag__var_1043)))) && ((v__1379.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && ((v__1379.subrange::<13, 15, 2>() == BitVector::<2>::new(0b10)) && (v__1379.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping115_hashtag_: BitVector<5> = v__1379.subrange::<7, 12, 5>();
                                                                                                                                                            let mapping114_hashtag_: BitVector<1> = v__1379.subrange::<12, 13, 1>();
                                                                                                                                                            let mapping113_hashtag_: BitVector<5> = v__1379.subrange::<15, 20, 5>();
                                                                                                                                                            let mapping112_hashtag_: BitVector<5> = v__1379.subrange::<20, 25, 5>();
                                                                                                                                                            match (encdec_reg_backwards(mapping112_hashtag_), encdec_reg_backwards(mapping113_hashtag_), bool_not_bits_backwards(mapping114_hashtag_), encdec_reg_backwards(mapping115_hashtag_)) {
                                                                                                                                                                (rs2, rs1, s, rd) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {Some(ast::DIVW((rs2, rs1, rd, s)))}
                                                                                                                                                                _ => {None}
                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                            }}
                                                                                                                                                            _ => {None}
                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                        } {
                                                                                                                                                            Some(result) => {result}
                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                v__1375 if {let mapping119_hashtag__var_1039: BitVector<5> = v__1375.subrange::<7, 12, 5>();
                                                                                                                                                                let mapping118_hashtag__var_1040: BitVector<1> = v__1375.subrange::<12, 13, 1>();
                                                                                                                                                                let mapping117_hashtag__var_1041: BitVector<5> = v__1375.subrange::<15, 20, 5>();
                                                                                                                                                                let mapping116_hashtag__var_1042: BitVector<5> = v__1375.subrange::<20, 25, 5>();
                                                                                                                                                                ((encdec_reg_backwards_matches(mapping116_hashtag__var_1042) && (encdec_reg_backwards_matches(mapping117_hashtag__var_1041) && (bool_not_bits_backwards_matches(mapping118_hashtag__var_1040) && encdec_reg_backwards_matches(mapping119_hashtag__var_1039)))) && ((v__1375.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && ((v__1375.subrange::<13, 15, 2>() == BitVector::<2>::new(0b11)) && (v__1375.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping119_hashtag_: BitVector<5> = v__1375.subrange::<7, 12, 5>();
                                                                                                                                                                let mapping118_hashtag_: BitVector<1> = v__1375.subrange::<12, 13, 1>();
                                                                                                                                                                let mapping117_hashtag_: BitVector<5> = v__1375.subrange::<15, 20, 5>();
                                                                                                                                                                let mapping116_hashtag_: BitVector<5> = v__1375.subrange::<20, 25, 5>();
                                                                                                                                                                match (encdec_reg_backwards(mapping116_hashtag_), encdec_reg_backwards(mapping117_hashtag_), bool_not_bits_backwards(mapping118_hashtag_), encdec_reg_backwards(mapping119_hashtag_)) {
                                                                                                                                                                    (rs2, rs1, s, rd) if {currentlyEnabled(core_ctx, extension::Ext_M)} => {Some(ast::REMW((rs2, rs1, rd, s)))}
                                                                                                                                                                    _ => {None}
                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                }}
                                                                                                                                                                _ => {None}
                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                            } {
                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                    v__1372 if {let mapping122_hashtag__var_1036: BitVector<5> = v__1372.subrange::<7, 12, 5>();
                                                                                                                                                                    let mapping121_hashtag__var_1037: BitVector<2> = v__1372.subrange::<12, 14, 2>();
                                                                                                                                                                    let mapping120_hashtag__var_1038: BitVector<5> = v__1372.subrange::<15, 20, 5>();
                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping120_hashtag__var_1038) && (encdec_csrop_backwards_matches(mapping121_hashtag__var_1037) && encdec_reg_backwards_matches(mapping122_hashtag__var_1036))) && ((v__1372.subrange::<14, 15, 1>() == BitVector::<1>::new(0b0)) && (v__1372.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110011))))} => {let csr: BitVector<12> = v__1372.subrange::<20, 32, 12>();
                                                                                                                                                                    let mapping122_hashtag_: BitVector<5> = v__1372.subrange::<7, 12, 5>();
                                                                                                                                                                    let mapping121_hashtag_: BitVector<2> = v__1372.subrange::<12, 14, 2>();
                                                                                                                                                                    let mapping120_hashtag_: BitVector<5> = v__1372.subrange::<15, 20, 5>();
                                                                                                                                                                    let csr: BitVector<12> = v__1372.subrange::<20, 32, 12>();
                                                                                                                                                                    match (encdec_reg_backwards(mapping120_hashtag_), encdec_csrop_backwards(mapping121_hashtag_), encdec_reg_backwards(mapping122_hashtag_)) {
                                                                                                                                                                        (rs1, op, rd) => {Some(ast::CSRReg((csr, rs1, rd, op)))}
                                                                                                                                                                        _ => {None}
                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                    }}
                                                                                                                                                                    _ => {None}
                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                } {
                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                        v__1369 if {let mapping124_hashtag__var_1034: BitVector<5> = v__1369.subrange::<7, 12, 5>();
                                                                                                                                                                        let mapping123_hashtag__var_1035: BitVector<2> = v__1369.subrange::<12, 14, 2>();
                                                                                                                                                                        ((encdec_csrop_backwards_matches(mapping123_hashtag__var_1035) && encdec_reg_backwards_matches(mapping124_hashtag__var_1034)) && ((v__1369.subrange::<14, 15, 1>() == BitVector::<1>::new(0b1)) && (v__1369.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110011))))} => {let csr: BitVector<12> = v__1369.subrange::<20, 32, 12>();
                                                                                                                                                                        let mapping124_hashtag_: BitVector<5> = v__1369.subrange::<7, 12, 5>();
                                                                                                                                                                        let mapping123_hashtag_: BitVector<2> = v__1369.subrange::<12, 14, 2>();
                                                                                                                                                                        let imm: BitVector<5> = v__1369.subrange::<15, 20, 5>();
                                                                                                                                                                        let csr: BitVector<12> = v__1369.subrange::<20, 32, 12>();
                                                                                                                                                                        match (encdec_csrop_backwards(mapping123_hashtag_), encdec_reg_backwards(mapping124_hashtag_)) {
                                                                                                                                                                            (op, rd) => {Some(ast::CSRImm((csr, imm, rd, op)))}
                                                                                                                                                                            _ => {None}
                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                        }}
                                                                                                                                                                        _ => {None}
                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                    } {
                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                            v__1366 if {let mapping126_hashtag__var_1032: BitVector<5> = v__1366.subrange::<7, 12, 5>();
                                                                                                                                                                            let mapping125_hashtag__var_1033: BitVector<5> = v__1366.subrange::<15, 20, 5>();
                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping125_hashtag__var_1033) && encdec_reg_backwards_matches(mapping126_hashtag__var_1032)) && ((v__1366.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1366.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0001111))))} => {let fm: BitVector<4> = v__1366.subrange::<28, 32, 4>();
                                                                                                                                                                            let succ: BitVector<4> = v__1366.subrange::<20, 24, 4>();
                                                                                                                                                                            let pred: BitVector<4> = v__1366.subrange::<24, 28, 4>();
                                                                                                                                                                            let mapping126_hashtag_: BitVector<5> = v__1366.subrange::<7, 12, 5>();
                                                                                                                                                                            let mapping125_hashtag_: BitVector<5> = v__1366.subrange::<15, 20, 5>();
                                                                                                                                                                            let fm: BitVector<4> = v__1366.subrange::<28, 32, 4>();
                                                                                                                                                                            match (encdec_reg_backwards(mapping125_hashtag_), encdec_reg_backwards(mapping126_hashtag_)) {
                                                                                                                                                                                (rs, rd) if {(((fm != BitVector::<4>::new(0b0000)) && (fm != BitVector::<4>::new(0b1000))) || ((rs != zreg) || (rd != zreg)))} => {Some(ast::FENCE_RESERVED((fm, pred, succ, rs, rd)))}
                                                                                                                                                                                _ => {None}
                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                            }}
                                                                                                                                                                            _ => {None}
                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                        } {
                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                v__1363 if {let mapping128_hashtag__var_1030: BitVector<5> = v__1363.subrange::<7, 12, 5>();
                                                                                                                                                                                let mapping127_hashtag__var_1031: BitVector<5> = v__1363.subrange::<15, 20, 5>();
                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping127_hashtag__var_1031) && encdec_reg_backwards_matches(mapping128_hashtag__var_1030)) && ((v__1363.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1363.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0001111))))} => {let imm: BitVector<12> = v__1363.subrange::<20, 32, 12>();
                                                                                                                                                                                let mapping128_hashtag_: BitVector<5> = v__1363.subrange::<7, 12, 5>();
                                                                                                                                                                                let mapping127_hashtag_: BitVector<5> = v__1363.subrange::<15, 20, 5>();
                                                                                                                                                                                let imm: BitVector<12> = v__1363.subrange::<20, 32, 12>();
                                                                                                                                                                                match (encdec_reg_backwards(mapping127_hashtag_), encdec_reg_backwards(mapping128_hashtag_)) {
                                                                                                                                                                                    (rs, rd) if {((imm != BitVector::<12>::new(0b000000000000)) || ((rs != zreg) || (rd != zreg)))} => {Some(ast::FENCEI_RESERVED((imm, rs, rd)))}
                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                }}
                                                                                                                                                                                _ => {None}
                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                            } {
                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                    v__1360 if {let mapping130_hashtag__var_1028: BitVector<5> = v__1360.subrange::<7, 12, 5>();
                                                                                                                                                                                    let mapping129_hashtag__var_1029: BitVector<5> = v__1360.subrange::<15, 20, 5>();
                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping129_hashtag__var_1029) && encdec_freg_backwards_matches(mapping130_hashtag__var_1028)) && ((v__1360.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1360.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let imm: BitVector<12> = v__1360.subrange::<20, 32, 12>();
                                                                                                                                                                                    let mapping130_hashtag_: BitVector<5> = v__1360.subrange::<7, 12, 5>();
                                                                                                                                                                                    let mapping129_hashtag_: BitVector<5> = v__1360.subrange::<15, 20, 5>();
                                                                                                                                                                                    let imm: BitVector<12> = v__1360.subrange::<20, 32, 12>();
                                                                                                                                                                                    match (encdec_reg_backwards(mapping129_hashtag_), encdec_freg_backwards(mapping130_hashtag_)) {
                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {Some(ast::LOAD_FP((imm, rs1, rd, word_width::HALF)))}
                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                    }}
                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                } {
                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                        v__1357 if {let mapping132_hashtag__var_1026: BitVector<5> = v__1357.subrange::<7, 12, 5>();
                                                                                                                                                                                        let mapping131_hashtag__var_1027: BitVector<5> = v__1357.subrange::<15, 20, 5>();
                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping131_hashtag__var_1027) && encdec_freg_backwards_matches(mapping132_hashtag__var_1026)) && ((v__1357.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1357.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let imm: BitVector<12> = v__1357.subrange::<20, 32, 12>();
                                                                                                                                                                                        let mapping132_hashtag_: BitVector<5> = v__1357.subrange::<7, 12, 5>();
                                                                                                                                                                                        let mapping131_hashtag_: BitVector<5> = v__1357.subrange::<15, 20, 5>();
                                                                                                                                                                                        let imm: BitVector<12> = v__1357.subrange::<20, 32, 12>();
                                                                                                                                                                                        match (encdec_reg_backwards(mapping131_hashtag_), encdec_freg_backwards(mapping132_hashtag_)) {
                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {Some(ast::LOAD_FP((imm, rs1, rd, word_width::WORD)))}
                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                        }}
                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                    } {
                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                            v__1354 if {let mapping134_hashtag__var_1024: BitVector<5> = v__1354.subrange::<7, 12, 5>();
                                                                                                                                                                                            let mapping133_hashtag__var_1025: BitVector<5> = v__1354.subrange::<15, 20, 5>();
                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping133_hashtag__var_1025) && encdec_freg_backwards_matches(mapping134_hashtag__var_1024)) && ((v__1354.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__1354.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let imm: BitVector<12> = v__1354.subrange::<20, 32, 12>();
                                                                                                                                                                                            let mapping134_hashtag_: BitVector<5> = v__1354.subrange::<7, 12, 5>();
                                                                                                                                                                                            let mapping133_hashtag_: BitVector<5> = v__1354.subrange::<15, 20, 5>();
                                                                                                                                                                                            let imm: BitVector<12> = v__1354.subrange::<20, 32, 12>();
                                                                                                                                                                                            match (encdec_reg_backwards(mapping133_hashtag_), encdec_freg_backwards(mapping134_hashtag_)) {
                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {Some(ast::LOAD_FP((imm, rs1, rd, word_width::DOUBLE)))}
                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                            }}
                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                        } {
                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                v__1351 if {let mapping136_hashtag__var_1022: BitVector<5> = v__1351.subrange::<15, 20, 5>();
                                                                                                                                                                                                let mapping135_hashtag__var_1023: BitVector<5> = v__1351.subrange::<20, 25, 5>();
                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping135_hashtag__var_1023) && encdec_reg_backwards_matches(mapping136_hashtag__var_1022)) && ((v__1351.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1351.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let imm7: BitVector<7> = v__1351.subrange::<25, 32, 7>();
                                                                                                                                                                                                let mapping136_hashtag_: BitVector<5> = v__1351.subrange::<15, 20, 5>();
                                                                                                                                                                                                let mapping135_hashtag_: BitVector<5> = v__1351.subrange::<20, 25, 5>();
                                                                                                                                                                                                let imm7: BitVector<7> = v__1351.subrange::<25, 32, 7>();
                                                                                                                                                                                                let imm5: BitVector<5> = v__1351.subrange::<7, 12, 5>();
                                                                                                                                                                                                match (encdec_freg_backwards(mapping135_hashtag_), encdec_reg_backwards(mapping136_hashtag_)) {
                                                                                                                                                                                                    (rs2, rs1) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {Some(ast::STORE_FP((bitvector_concat::<7, 5, 12>((imm7 as BitVector<7>), (imm5 as BitVector<5>)), rs2, rs1, word_width::HALF)))}
                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                }}
                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                            } {
                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                    v__1348 if {let mapping138_hashtag__var_1020: BitVector<5> = v__1348.subrange::<15, 20, 5>();
                                                                                                                                                                                                    let mapping137_hashtag__var_1021: BitVector<5> = v__1348.subrange::<20, 25, 5>();
                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping137_hashtag__var_1021) && encdec_reg_backwards_matches(mapping138_hashtag__var_1020)) && ((v__1348.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1348.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let imm7: BitVector<7> = v__1348.subrange::<25, 32, 7>();
                                                                                                                                                                                                    let mapping138_hashtag_: BitVector<5> = v__1348.subrange::<15, 20, 5>();
                                                                                                                                                                                                    let mapping137_hashtag_: BitVector<5> = v__1348.subrange::<20, 25, 5>();
                                                                                                                                                                                                    let imm7: BitVector<7> = v__1348.subrange::<25, 32, 7>();
                                                                                                                                                                                                    let imm5: BitVector<5> = v__1348.subrange::<7, 12, 5>();
                                                                                                                                                                                                    match (encdec_freg_backwards(mapping137_hashtag_), encdec_reg_backwards(mapping138_hashtag_)) {
                                                                                                                                                                                                        (rs2, rs1) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {Some(ast::STORE_FP((bitvector_concat::<7, 5, 12>((imm7 as BitVector<7>), (imm5 as BitVector<5>)), rs2, rs1, word_width::WORD)))}
                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                    }}
                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                } {
                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                        v__1345 if {let mapping140_hashtag__var_1018: BitVector<5> = v__1345.subrange::<15, 20, 5>();
                                                                                                                                                                                                        let mapping139_hashtag__var_1019: BitVector<5> = v__1345.subrange::<20, 25, 5>();
                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping139_hashtag__var_1019) && encdec_reg_backwards_matches(mapping140_hashtag__var_1018)) && ((v__1345.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__1345.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let imm7: BitVector<7> = v__1345.subrange::<25, 32, 7>();
                                                                                                                                                                                                        let mapping140_hashtag_: BitVector<5> = v__1345.subrange::<15, 20, 5>();
                                                                                                                                                                                                        let mapping139_hashtag_: BitVector<5> = v__1345.subrange::<20, 25, 5>();
                                                                                                                                                                                                        let imm7: BitVector<7> = v__1345.subrange::<25, 32, 7>();
                                                                                                                                                                                                        let imm5: BitVector<5> = v__1345.subrange::<7, 12, 5>();
                                                                                                                                                                                                        match (encdec_freg_backwards(mapping139_hashtag_), encdec_reg_backwards(mapping140_hashtag_)) {
                                                                                                                                                                                                            (rs2, rs1) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {Some(ast::STORE_FP((bitvector_concat::<7, 5, 12>((imm7 as BitVector<7>), (imm5 as BitVector<5>)), rs2, rs1, word_width::DOUBLE)))}
                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                        }}
                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                    } {
                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                            v__1342 if {let mapping141_hashtag__var_1012: BitVector<5> = v__1342.subrange::<27, 32, 5>();
                                                                                                                                                                                                            let mapping145_hashtag__var_1013: BitVector<5> = v__1342.subrange::<7, 12, 5>();
                                                                                                                                                                                                            let mapping144_hashtag__var_1014: BitVector<3> = v__1342.subrange::<12, 15, 3>();
                                                                                                                                                                                                            let mapping143_hashtag__var_1015: BitVector<5> = v__1342.subrange::<15, 20, 5>();
                                                                                                                                                                                                            let mapping142_hashtag__var_1016: BitVector<5> = v__1342.subrange::<20, 25, 5>();
                                                                                                                                                                                                            let mapping141_hashtag__var_1017: BitVector<5> = v__1342.subrange::<27, 32, 5>();
                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping141_hashtag__var_1017) && (encdec_freg_backwards_matches(mapping142_hashtag__var_1016) && (encdec_freg_backwards_matches(mapping143_hashtag__var_1015) && (encdec_rounding_mode_backwards_matches(mapping144_hashtag__var_1014) && encdec_freg_backwards_matches(mapping145_hashtag__var_1013))))) && ((v__1342.subrange::<25, 27, 2>() == BitVector::<2>::new(0b00)) && (v__1342.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000011))))} => {let mapping141_hashtag_: BitVector<5> = v__1342.subrange::<27, 32, 5>();
                                                                                                                                                                                                            let mapping145_hashtag_: BitVector<5> = v__1342.subrange::<7, 12, 5>();
                                                                                                                                                                                                            let mapping144_hashtag_: BitVector<3> = v__1342.subrange::<12, 15, 3>();
                                                                                                                                                                                                            let mapping143_hashtag_: BitVector<5> = v__1342.subrange::<15, 20, 5>();
                                                                                                                                                                                                            let mapping142_hashtag_: BitVector<5> = v__1342.subrange::<20, 25, 5>();
                                                                                                                                                                                                            let mapping141_hashtag_: BitVector<5> = v__1342.subrange::<27, 32, 5>();
                                                                                                                                                                                                            match (encdec_freg_backwards(mapping141_hashtag_), encdec_freg_backwards(mapping142_hashtag_), encdec_freg_backwards(mapping143_hashtag_), encdec_rounding_mode_backwards(mapping144_hashtag_), encdec_freg_backwards(mapping145_hashtag_)) {
                                                                                                                                                                                                                (rs3, rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FMADD_S)))}
                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                            }}
                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                        } {
                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                v__1339 if {let mapping146_hashtag__var_1006: BitVector<5> = v__1339.subrange::<27, 32, 5>();
                                                                                                                                                                                                                let mapping150_hashtag__var_1007: BitVector<5> = v__1339.subrange::<7, 12, 5>();
                                                                                                                                                                                                                let mapping149_hashtag__var_1008: BitVector<3> = v__1339.subrange::<12, 15, 3>();
                                                                                                                                                                                                                let mapping148_hashtag__var_1009: BitVector<5> = v__1339.subrange::<15, 20, 5>();
                                                                                                                                                                                                                let mapping147_hashtag__var_1010: BitVector<5> = v__1339.subrange::<20, 25, 5>();
                                                                                                                                                                                                                let mapping146_hashtag__var_1011: BitVector<5> = v__1339.subrange::<27, 32, 5>();
                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping146_hashtag__var_1011) && (encdec_freg_backwards_matches(mapping147_hashtag__var_1010) && (encdec_freg_backwards_matches(mapping148_hashtag__var_1009) && (encdec_rounding_mode_backwards_matches(mapping149_hashtag__var_1008) && encdec_freg_backwards_matches(mapping150_hashtag__var_1007))))) && ((v__1339.subrange::<25, 27, 2>() == BitVector::<2>::new(0b00)) && (v__1339.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000111))))} => {let mapping146_hashtag_: BitVector<5> = v__1339.subrange::<27, 32, 5>();
                                                                                                                                                                                                                let mapping150_hashtag_: BitVector<5> = v__1339.subrange::<7, 12, 5>();
                                                                                                                                                                                                                let mapping149_hashtag_: BitVector<3> = v__1339.subrange::<12, 15, 3>();
                                                                                                                                                                                                                let mapping148_hashtag_: BitVector<5> = v__1339.subrange::<15, 20, 5>();
                                                                                                                                                                                                                let mapping147_hashtag_: BitVector<5> = v__1339.subrange::<20, 25, 5>();
                                                                                                                                                                                                                let mapping146_hashtag_: BitVector<5> = v__1339.subrange::<27, 32, 5>();
                                                                                                                                                                                                                match (encdec_freg_backwards(mapping146_hashtag_), encdec_freg_backwards(mapping147_hashtag_), encdec_freg_backwards(mapping148_hashtag_), encdec_rounding_mode_backwards(mapping149_hashtag_), encdec_freg_backwards(mapping150_hashtag_)) {
                                                                                                                                                                                                                    (rs3, rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FMSUB_S)))}
                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                }}
                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                            } {
                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                    v__1336 if {let mapping151_hashtag__var_1000: BitVector<5> = v__1336.subrange::<27, 32, 5>();
                                                                                                                                                                                                                    let mapping155_hashtag__var_1001: BitVector<5> = v__1336.subrange::<7, 12, 5>();
                                                                                                                                                                                                                    let mapping154_hashtag__var_1002: BitVector<3> = v__1336.subrange::<12, 15, 3>();
                                                                                                                                                                                                                    let mapping153_hashtag__var_1003: BitVector<5> = v__1336.subrange::<15, 20, 5>();
                                                                                                                                                                                                                    let mapping152_hashtag__var_1004: BitVector<5> = v__1336.subrange::<20, 25, 5>();
                                                                                                                                                                                                                    let mapping151_hashtag__var_1005: BitVector<5> = v__1336.subrange::<27, 32, 5>();
                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping151_hashtag__var_1005) && (encdec_freg_backwards_matches(mapping152_hashtag__var_1004) && (encdec_freg_backwards_matches(mapping153_hashtag__var_1003) && (encdec_rounding_mode_backwards_matches(mapping154_hashtag__var_1002) && encdec_freg_backwards_matches(mapping155_hashtag__var_1001))))) && ((v__1336.subrange::<25, 27, 2>() == BitVector::<2>::new(0b00)) && (v__1336.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001011))))} => {let mapping151_hashtag_: BitVector<5> = v__1336.subrange::<27, 32, 5>();
                                                                                                                                                                                                                    let mapping155_hashtag_: BitVector<5> = v__1336.subrange::<7, 12, 5>();
                                                                                                                                                                                                                    let mapping154_hashtag_: BitVector<3> = v__1336.subrange::<12, 15, 3>();
                                                                                                                                                                                                                    let mapping153_hashtag_: BitVector<5> = v__1336.subrange::<15, 20, 5>();
                                                                                                                                                                                                                    let mapping152_hashtag_: BitVector<5> = v__1336.subrange::<20, 25, 5>();
                                                                                                                                                                                                                    let mapping151_hashtag_: BitVector<5> = v__1336.subrange::<27, 32, 5>();
                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping151_hashtag_), encdec_freg_backwards(mapping152_hashtag_), encdec_freg_backwards(mapping153_hashtag_), encdec_rounding_mode_backwards(mapping154_hashtag_), encdec_freg_backwards(mapping155_hashtag_)) {
                                                                                                                                                                                                                        (rs3, rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FNMSUB_S)))}
                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                } {
                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                        v__1333 if {let mapping156_hashtag__var_994: BitVector<5> = v__1333.subrange::<27, 32, 5>();
                                                                                                                                                                                                                        let mapping160_hashtag__var_995: BitVector<5> = v__1333.subrange::<7, 12, 5>();
                                                                                                                                                                                                                        let mapping159_hashtag__var_996: BitVector<3> = v__1333.subrange::<12, 15, 3>();
                                                                                                                                                                                                                        let mapping158_hashtag__var_997: BitVector<5> = v__1333.subrange::<15, 20, 5>();
                                                                                                                                                                                                                        let mapping157_hashtag__var_998: BitVector<5> = v__1333.subrange::<20, 25, 5>();
                                                                                                                                                                                                                        let mapping156_hashtag__var_999: BitVector<5> = v__1333.subrange::<27, 32, 5>();
                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping156_hashtag__var_999) && (encdec_freg_backwards_matches(mapping157_hashtag__var_998) && (encdec_freg_backwards_matches(mapping158_hashtag__var_997) && (encdec_rounding_mode_backwards_matches(mapping159_hashtag__var_996) && encdec_freg_backwards_matches(mapping160_hashtag__var_995))))) && ((v__1333.subrange::<25, 27, 2>() == BitVector::<2>::new(0b00)) && (v__1333.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001111))))} => {let mapping156_hashtag_: BitVector<5> = v__1333.subrange::<27, 32, 5>();
                                                                                                                                                                                                                        let mapping160_hashtag_: BitVector<5> = v__1333.subrange::<7, 12, 5>();
                                                                                                                                                                                                                        let mapping159_hashtag_: BitVector<3> = v__1333.subrange::<12, 15, 3>();
                                                                                                                                                                                                                        let mapping158_hashtag_: BitVector<5> = v__1333.subrange::<15, 20, 5>();
                                                                                                                                                                                                                        let mapping157_hashtag_: BitVector<5> = v__1333.subrange::<20, 25, 5>();
                                                                                                                                                                                                                        let mapping156_hashtag_: BitVector<5> = v__1333.subrange::<27, 32, 5>();
                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping156_hashtag_), encdec_freg_backwards(mapping157_hashtag_), encdec_freg_backwards(mapping158_hashtag_), encdec_rounding_mode_backwards(mapping159_hashtag_), encdec_freg_backwards(mapping160_hashtag_)) {
                                                                                                                                                                                                                            (rs3, rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, f_madd_op_S::FNMADD_S)))}
                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                            v__1330 if {let mapping164_hashtag__var_990: BitVector<5> = v__1330.subrange::<7, 12, 5>();
                                                                                                                                                                                                                            let mapping163_hashtag__var_991: BitVector<3> = v__1330.subrange::<12, 15, 3>();
                                                                                                                                                                                                                            let mapping162_hashtag__var_992: BitVector<5> = v__1330.subrange::<15, 20, 5>();
                                                                                                                                                                                                                            let mapping161_hashtag__var_993: BitVector<5> = v__1330.subrange::<20, 25, 5>();
                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping161_hashtag__var_993) && (encdec_freg_backwards_matches(mapping162_hashtag__var_992) && (encdec_rounding_mode_backwards_matches(mapping163_hashtag__var_991) && encdec_freg_backwards_matches(mapping164_hashtag__var_990)))) && ((v__1330.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000000)) && (v__1330.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping164_hashtag_: BitVector<5> = v__1330.subrange::<7, 12, 5>();
                                                                                                                                                                                                                            let mapping163_hashtag_: BitVector<3> = v__1330.subrange::<12, 15, 3>();
                                                                                                                                                                                                                            let mapping162_hashtag_: BitVector<5> = v__1330.subrange::<15, 20, 5>();
                                                                                                                                                                                                                            let mapping161_hashtag_: BitVector<5> = v__1330.subrange::<20, 25, 5>();
                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping161_hashtag_), encdec_freg_backwards(mapping162_hashtag_), encdec_rounding_mode_backwards(mapping163_hashtag_), encdec_freg_backwards(mapping164_hashtag_)) {
                                                                                                                                                                                                                                (rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FADD_S)))}
                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                v__1327 if {let mapping168_hashtag__var_986: BitVector<5> = v__1327.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                let mapping167_hashtag__var_987: BitVector<3> = v__1327.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                let mapping166_hashtag__var_988: BitVector<5> = v__1327.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                let mapping165_hashtag__var_989: BitVector<5> = v__1327.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping165_hashtag__var_989) && (encdec_freg_backwards_matches(mapping166_hashtag__var_988) && (encdec_rounding_mode_backwards_matches(mapping167_hashtag__var_987) && encdec_freg_backwards_matches(mapping168_hashtag__var_986)))) && ((v__1327.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000100)) && (v__1327.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping168_hashtag_: BitVector<5> = v__1327.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                let mapping167_hashtag_: BitVector<3> = v__1327.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                let mapping166_hashtag_: BitVector<5> = v__1327.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                let mapping165_hashtag_: BitVector<5> = v__1327.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping165_hashtag_), encdec_freg_backwards(mapping166_hashtag_), encdec_rounding_mode_backwards(mapping167_hashtag_), encdec_freg_backwards(mapping168_hashtag_)) {
                                                                                                                                                                                                                                    (rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FSUB_S)))}
                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                    v__1324 if {let mapping172_hashtag__var_982: BitVector<5> = v__1324.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                    let mapping171_hashtag__var_983: BitVector<3> = v__1324.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                    let mapping170_hashtag__var_984: BitVector<5> = v__1324.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                    let mapping169_hashtag__var_985: BitVector<5> = v__1324.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping169_hashtag__var_985) && (encdec_freg_backwards_matches(mapping170_hashtag__var_984) && (encdec_rounding_mode_backwards_matches(mapping171_hashtag__var_983) && encdec_freg_backwards_matches(mapping172_hashtag__var_982)))) && ((v__1324.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001000)) && (v__1324.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping172_hashtag_: BitVector<5> = v__1324.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                    let mapping171_hashtag_: BitVector<3> = v__1324.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                    let mapping170_hashtag_: BitVector<5> = v__1324.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                    let mapping169_hashtag_: BitVector<5> = v__1324.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping169_hashtag_), encdec_freg_backwards(mapping170_hashtag_), encdec_rounding_mode_backwards(mapping171_hashtag_), encdec_freg_backwards(mapping172_hashtag_)) {
                                                                                                                                                                                                                                        (rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FMUL_S)))}
                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                        v__1321 if {let mapping176_hashtag__var_978: BitVector<5> = v__1321.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                        let mapping175_hashtag__var_979: BitVector<3> = v__1321.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                        let mapping174_hashtag__var_980: BitVector<5> = v__1321.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                        let mapping173_hashtag__var_981: BitVector<5> = v__1321.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping173_hashtag__var_981) && (encdec_freg_backwards_matches(mapping174_hashtag__var_980) && (encdec_rounding_mode_backwards_matches(mapping175_hashtag__var_979) && encdec_freg_backwards_matches(mapping176_hashtag__var_978)))) && ((v__1321.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001100)) && (v__1321.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping176_hashtag_: BitVector<5> = v__1321.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                        let mapping175_hashtag_: BitVector<3> = v__1321.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                        let mapping174_hashtag_: BitVector<5> = v__1321.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                        let mapping173_hashtag_: BitVector<5> = v__1321.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping173_hashtag_), encdec_freg_backwards(mapping174_hashtag_), encdec_rounding_mode_backwards(mapping175_hashtag_), encdec_freg_backwards(mapping176_hashtag_)) {
                                                                                                                                                                                                                                            (rs2, rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, f_bin_rm_op_S::FDIV_S)))}
                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                            v__1317 if {let mapping179_hashtag__var_975: BitVector<5> = v__1317.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                            let mapping178_hashtag__var_976: BitVector<3> = v__1317.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                            let mapping177_hashtag__var_977: BitVector<5> = v__1317.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping177_hashtag__var_977) && (encdec_rounding_mode_backwards_matches(mapping178_hashtag__var_976) && encdec_freg_backwards_matches(mapping179_hashtag__var_975))) && ((v__1317.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010110000000)) && (v__1317.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping179_hashtag_: BitVector<5> = v__1317.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                            let mapping178_hashtag_: BitVector<3> = v__1317.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                            let mapping177_hashtag_: BitVector<5> = v__1317.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping177_hashtag_), encdec_rounding_mode_backwards(mapping178_hashtag_), encdec_freg_backwards(mapping179_hashtag_)) {
                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_S((rs1, rm, rd, f_un_rm_ff_op_S::FSQRT_S)))}
                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                v__1313 if {let mapping182_hashtag__var_972: BitVector<5> = v__1313.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                let mapping181_hashtag__var_973: BitVector<3> = v__1313.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                let mapping180_hashtag__var_974: BitVector<5> = v__1313.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping180_hashtag__var_974) && (encdec_rounding_mode_backwards_matches(mapping181_hashtag__var_973) && encdec_reg_backwards_matches(mapping182_hashtag__var_972))) && ((v__1313.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000000000)) && (v__1313.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping182_hashtag_: BitVector<5> = v__1313.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                let mapping181_hashtag_: BitVector<3> = v__1313.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                let mapping180_hashtag_: BitVector<5> = v__1313.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping180_hashtag_), encdec_rounding_mode_backwards(mapping181_hashtag_), encdec_reg_backwards(mapping182_hashtag_)) {
                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_W_S)))}
                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                    v__1309 if {let mapping185_hashtag__var_969: BitVector<5> = v__1309.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                    let mapping184_hashtag__var_970: BitVector<3> = v__1309.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                    let mapping183_hashtag__var_971: BitVector<5> = v__1309.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping183_hashtag__var_971) && (encdec_rounding_mode_backwards_matches(mapping184_hashtag__var_970) && encdec_reg_backwards_matches(mapping185_hashtag__var_969))) && ((v__1309.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000000001)) && (v__1309.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping185_hashtag_: BitVector<5> = v__1309.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                    let mapping184_hashtag_: BitVector<3> = v__1309.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                    let mapping183_hashtag_: BitVector<5> = v__1309.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping183_hashtag_), encdec_rounding_mode_backwards(mapping184_hashtag_), encdec_reg_backwards(mapping185_hashtag_)) {
                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_WU_S)))}
                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                        v__1305 if {let mapping188_hashtag__var_966: BitVector<5> = v__1305.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                        let mapping187_hashtag__var_967: BitVector<3> = v__1305.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                        let mapping186_hashtag__var_968: BitVector<5> = v__1305.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping186_hashtag__var_968) && (encdec_rounding_mode_backwards_matches(mapping187_hashtag__var_967) && encdec_freg_backwards_matches(mapping188_hashtag__var_966))) && ((v__1305.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100000000)) && (v__1305.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping188_hashtag_: BitVector<5> = v__1305.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                        let mapping187_hashtag_: BitVector<3> = v__1305.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                        let mapping186_hashtag_: BitVector<5> = v__1305.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping186_hashtag_), encdec_rounding_mode_backwards(mapping187_hashtag_), encdec_freg_backwards(mapping188_hashtag_)) {
                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_W)))}
                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                            v__1301 if {let mapping191_hashtag__var_963: BitVector<5> = v__1301.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                            let mapping190_hashtag__var_964: BitVector<3> = v__1301.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                            let mapping189_hashtag__var_965: BitVector<5> = v__1301.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping189_hashtag__var_965) && (encdec_rounding_mode_backwards_matches(mapping190_hashtag__var_964) && encdec_freg_backwards_matches(mapping191_hashtag__var_963))) && ((v__1301.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100000001)) && (v__1301.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping191_hashtag_: BitVector<5> = v__1301.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                            let mapping190_hashtag_: BitVector<3> = v__1301.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                            let mapping189_hashtag_: BitVector<5> = v__1301.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping189_hashtag_), encdec_rounding_mode_backwards(mapping190_hashtag_), encdec_freg_backwards(mapping191_hashtag_)) {
                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_WU)))}
                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                v__1297 if {let mapping194_hashtag__var_960: BitVector<5> = v__1297.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                let mapping193_hashtag__var_961: BitVector<3> = v__1297.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                let mapping192_hashtag__var_962: BitVector<5> = v__1297.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping192_hashtag__var_962) && (encdec_rounding_mode_backwards_matches(mapping193_hashtag__var_961) && encdec_reg_backwards_matches(mapping194_hashtag__var_960))) && ((v__1297.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000000010)) && (v__1297.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping194_hashtag_: BitVector<5> = v__1297.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                let mapping193_hashtag_: BitVector<3> = v__1297.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                let mapping192_hashtag_: BitVector<5> = v__1297.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping192_hashtag_), encdec_rounding_mode_backwards(mapping193_hashtag_), encdec_reg_backwards(mapping194_hashtag_)) {
                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_L_S)))}
                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                    v__1293 if {let mapping197_hashtag__var_957: BitVector<5> = v__1293.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                    let mapping196_hashtag__var_958: BitVector<3> = v__1293.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                    let mapping195_hashtag__var_959: BitVector<5> = v__1293.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping195_hashtag__var_959) && (encdec_rounding_mode_backwards_matches(mapping196_hashtag__var_958) && encdec_reg_backwards_matches(mapping197_hashtag__var_957))) && ((v__1293.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000000011)) && (v__1293.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping197_hashtag_: BitVector<5> = v__1293.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                    let mapping196_hashtag_: BitVector<3> = v__1293.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                    let mapping195_hashtag_: BitVector<5> = v__1293.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping195_hashtag_), encdec_rounding_mode_backwards(mapping196_hashtag_), encdec_reg_backwards(mapping197_hashtag_)) {
                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_LU_S)))}
                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                        v__1289 if {let mapping200_hashtag__var_954: BitVector<5> = v__1289.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                        let mapping199_hashtag__var_955: BitVector<3> = v__1289.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                        let mapping198_hashtag__var_956: BitVector<5> = v__1289.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping198_hashtag__var_956) && (encdec_rounding_mode_backwards_matches(mapping199_hashtag__var_955) && encdec_freg_backwards_matches(mapping200_hashtag__var_954))) && ((v__1289.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100000010)) && (v__1289.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping200_hashtag_: BitVector<5> = v__1289.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                        let mapping199_hashtag_: BitVector<3> = v__1289.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                        let mapping198_hashtag_: BitVector<5> = v__1289.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping198_hashtag_), encdec_rounding_mode_backwards(mapping199_hashtag_), encdec_freg_backwards(mapping200_hashtag_)) {
                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_L)))}
                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                            v__1285 if {let mapping203_hashtag__var_951: BitVector<5> = v__1285.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                            let mapping202_hashtag__var_952: BitVector<3> = v__1285.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                            let mapping201_hashtag__var_953: BitVector<5> = v__1285.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping201_hashtag__var_953) && (encdec_rounding_mode_backwards_matches(mapping202_hashtag__var_952) && encdec_freg_backwards_matches(mapping203_hashtag__var_951))) && ((v__1285.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100000011)) && (v__1285.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping203_hashtag_: BitVector<5> = v__1285.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                            let mapping202_hashtag_: BitVector<3> = v__1285.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                            let mapping201_hashtag_: BitVector<5> = v__1285.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping201_hashtag_), encdec_rounding_mode_backwards(mapping202_hashtag_), encdec_freg_backwards(mapping203_hashtag_)) {
                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_LU)))}
                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                v__1281 if {let mapping206_hashtag__var_948: BitVector<5> = v__1281.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                let mapping205_hashtag__var_949: BitVector<5> = v__1281.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                let mapping204_hashtag__var_950: BitVector<5> = v__1281.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping204_hashtag__var_950) && (encdec_freg_backwards_matches(mapping205_hashtag__var_949) && encdec_freg_backwards_matches(mapping206_hashtag__var_948))) && ((v__1281.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1281.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1281.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping206_hashtag_: BitVector<5> = v__1281.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                let mapping205_hashtag_: BitVector<5> = v__1281.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                let mapping204_hashtag_: BitVector<5> = v__1281.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping204_hashtag_), encdec_freg_backwards(mapping205_hashtag_), encdec_freg_backwards(mapping206_hashtag_)) {
                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJ_S)))}
                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                    v__1277 if {let mapping209_hashtag__var_945: BitVector<5> = v__1277.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                    let mapping208_hashtag__var_946: BitVector<5> = v__1277.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                    let mapping207_hashtag__var_947: BitVector<5> = v__1277.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping207_hashtag__var_947) && (encdec_freg_backwards_matches(mapping208_hashtag__var_946) && encdec_freg_backwards_matches(mapping209_hashtag__var_945))) && ((v__1277.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1277.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1277.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping209_hashtag_: BitVector<5> = v__1277.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                    let mapping208_hashtag_: BitVector<5> = v__1277.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                    let mapping207_hashtag_: BitVector<5> = v__1277.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping207_hashtag_), encdec_freg_backwards(mapping208_hashtag_), encdec_freg_backwards(mapping209_hashtag_)) {
                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJN_S)))}
                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                        v__1273 if {let mapping212_hashtag__var_942: BitVector<5> = v__1273.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                        let mapping211_hashtag__var_943: BitVector<5> = v__1273.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                        let mapping210_hashtag__var_944: BitVector<5> = v__1273.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping210_hashtag__var_944) && (encdec_freg_backwards_matches(mapping211_hashtag__var_943) && encdec_freg_backwards_matches(mapping212_hashtag__var_942))) && ((v__1273.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1273.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1273.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping212_hashtag_: BitVector<5> = v__1273.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                        let mapping211_hashtag_: BitVector<5> = v__1273.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                        let mapping210_hashtag_: BitVector<5> = v__1273.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping210_hashtag_), encdec_freg_backwards(mapping211_hashtag_), encdec_freg_backwards(mapping212_hashtag_)) {
                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJX_S)))}
                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                            v__1269 if {let mapping215_hashtag__var_939: BitVector<5> = v__1269.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                            let mapping214_hashtag__var_940: BitVector<5> = v__1269.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                            let mapping213_hashtag__var_941: BitVector<5> = v__1269.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping213_hashtag__var_941) && (encdec_freg_backwards_matches(mapping214_hashtag__var_940) && encdec_freg_backwards_matches(mapping215_hashtag__var_939))) && ((v__1269.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__1269.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1269.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping215_hashtag_: BitVector<5> = v__1269.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                            let mapping214_hashtag_: BitVector<5> = v__1269.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                            let mapping213_hashtag_: BitVector<5> = v__1269.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping213_hashtag_), encdec_freg_backwards(mapping214_hashtag_), encdec_freg_backwards(mapping215_hashtag_)) {
                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMIN_S)))}
                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                v__1265 if {let mapping218_hashtag__var_936: BitVector<5> = v__1265.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                let mapping217_hashtag__var_937: BitVector<5> = v__1265.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                let mapping216_hashtag__var_938: BitVector<5> = v__1265.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping216_hashtag__var_938) && (encdec_freg_backwards_matches(mapping217_hashtag__var_937) && encdec_freg_backwards_matches(mapping218_hashtag__var_936))) && ((v__1265.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__1265.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1265.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping218_hashtag_: BitVector<5> = v__1265.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                let mapping217_hashtag_: BitVector<5> = v__1265.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                let mapping216_hashtag_: BitVector<5> = v__1265.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping216_hashtag_), encdec_freg_backwards(mapping217_hashtag_), encdec_freg_backwards(mapping218_hashtag_)) {
                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMAX_S)))}
                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                    v__1261 if {let mapping221_hashtag__var_933: BitVector<5> = v__1261.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                    let mapping220_hashtag__var_934: BitVector<5> = v__1261.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                    let mapping219_hashtag__var_935: BitVector<5> = v__1261.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping219_hashtag__var_935) && (encdec_freg_backwards_matches(mapping220_hashtag__var_934) && encdec_reg_backwards_matches(mapping221_hashtag__var_933))) && ((v__1261.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010000)) && ((v__1261.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1261.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping221_hashtag_: BitVector<5> = v__1261.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                    let mapping220_hashtag_: BitVector<5> = v__1261.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                    let mapping219_hashtag_: BitVector<5> = v__1261.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping219_hashtag_), encdec_freg_backwards(mapping220_hashtag_), encdec_reg_backwards(mapping221_hashtag_)) {
                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FEQ_S)))}
                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                        v__1257 if {let mapping224_hashtag__var_930: BitVector<5> = v__1257.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                        let mapping223_hashtag__var_931: BitVector<5> = v__1257.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                        let mapping222_hashtag__var_932: BitVector<5> = v__1257.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping222_hashtag__var_932) && (encdec_freg_backwards_matches(mapping223_hashtag__var_931) && encdec_reg_backwards_matches(mapping224_hashtag__var_930))) && ((v__1257.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010000)) && ((v__1257.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1257.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping224_hashtag_: BitVector<5> = v__1257.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                        let mapping223_hashtag_: BitVector<5> = v__1257.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                        let mapping222_hashtag_: BitVector<5> = v__1257.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping222_hashtag_), encdec_freg_backwards(mapping223_hashtag_), encdec_reg_backwards(mapping224_hashtag_)) {
                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLT_S)))}
                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                            v__1253 if {let mapping227_hashtag__var_927: BitVector<5> = v__1253.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                            let mapping226_hashtag__var_928: BitVector<5> = v__1253.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                            let mapping225_hashtag__var_929: BitVector<5> = v__1253.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping225_hashtag__var_929) && (encdec_freg_backwards_matches(mapping226_hashtag__var_928) && encdec_reg_backwards_matches(mapping227_hashtag__var_927))) && ((v__1253.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010000)) && ((v__1253.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1253.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping227_hashtag_: BitVector<5> = v__1253.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                            let mapping226_hashtag_: BitVector<5> = v__1253.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                            let mapping225_hashtag_: BitVector<5> = v__1253.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping225_hashtag_), encdec_freg_backwards(mapping226_hashtag_), encdec_reg_backwards(mapping227_hashtag_)) {
                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLE_S)))}
                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                v__1248 if {let mapping229_hashtag__var_925: BitVector<5> = v__1248.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                let mapping228_hashtag__var_926: BitVector<5> = v__1248.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping228_hashtag__var_926) && encdec_reg_backwards_matches(mapping229_hashtag__var_925)) && ((v__1248.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111000000000)) && ((v__1248.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1248.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping229_hashtag_: BitVector<5> = v__1248.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                let mapping228_hashtag_: BitVector<5> = v__1248.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping228_hashtag_), encdec_reg_backwards(mapping229_hashtag_)) {
                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {haveSingleFPU(core_ctx, ())} => {Some(ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FCLASS_S)))}
                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                    v__1243 if {let mapping231_hashtag__var_923: BitVector<5> = v__1243.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                    let mapping230_hashtag__var_924: BitVector<5> = v__1243.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping230_hashtag__var_924) && encdec_reg_backwards_matches(mapping231_hashtag__var_923)) && ((v__1243.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111000000000)) && ((v__1243.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1243.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping231_hashtag_: BitVector<5> = v__1243.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                    let mapping230_hashtag_: BitVector<5> = v__1243.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping230_hashtag_), encdec_reg_backwards(mapping231_hashtag_)) {
                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {Some(ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FMV_X_W)))}
                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                        v__1238 if {let mapping233_hashtag__var_921: BitVector<5> = v__1238.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                        let mapping232_hashtag__var_922: BitVector<5> = v__1238.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping232_hashtag__var_922) && encdec_freg_backwards_matches(mapping233_hashtag__var_921)) && ((v__1238.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111100000000)) && ((v__1238.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1238.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping233_hashtag_: BitVector<5> = v__1238.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                        let mapping232_hashtag_: BitVector<5> = v__1238.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping232_hashtag_), encdec_freg_backwards(mapping233_hashtag_)) {
                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_F)} => {Some(ast::F_UN_TYPE_F_S((rs1, rd, f_un_op_f_S::FMV_W_X)))}
                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                            v__1235 if {let mapping234_hashtag__var_915: BitVector<5> = v__1235.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping238_hashtag__var_916: BitVector<5> = v__1235.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping237_hashtag__var_917: BitVector<3> = v__1235.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                            let mapping236_hashtag__var_918: BitVector<5> = v__1235.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping235_hashtag__var_919: BitVector<5> = v__1235.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping234_hashtag__var_920: BitVector<5> = v__1235.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping234_hashtag__var_920) && (encdec_freg_backwards_matches(mapping235_hashtag__var_919) && (encdec_freg_backwards_matches(mapping236_hashtag__var_918) && (encdec_rounding_mode_backwards_matches(mapping237_hashtag__var_917) && encdec_freg_backwards_matches(mapping238_hashtag__var_916))))) && ((v__1235.subrange::<25, 27, 2>() == BitVector::<2>::new(0b01)) && (v__1235.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000011))))} => {let mapping234_hashtag_: BitVector<5> = v__1235.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping238_hashtag_: BitVector<5> = v__1235.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping237_hashtag_: BitVector<3> = v__1235.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                            let mapping236_hashtag_: BitVector<5> = v__1235.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping235_hashtag_: BitVector<5> = v__1235.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                            let mapping234_hashtag_: BitVector<5> = v__1235.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping234_hashtag_), encdec_freg_backwards(mapping235_hashtag_), encdec_freg_backwards(mapping236_hashtag_), encdec_rounding_mode_backwards(mapping237_hashtag_), encdec_freg_backwards(mapping238_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                (rs3, rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FMADD_D)))}
                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                v__1232 if {let mapping239_hashtag__var_909: BitVector<5> = v__1232.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping243_hashtag__var_910: BitVector<5> = v__1232.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping242_hashtag__var_911: BitVector<3> = v__1232.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                let mapping241_hashtag__var_912: BitVector<5> = v__1232.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping240_hashtag__var_913: BitVector<5> = v__1232.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping239_hashtag__var_914: BitVector<5> = v__1232.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping239_hashtag__var_914) && (encdec_freg_backwards_matches(mapping240_hashtag__var_913) && (encdec_freg_backwards_matches(mapping241_hashtag__var_912) && (encdec_rounding_mode_backwards_matches(mapping242_hashtag__var_911) && encdec_freg_backwards_matches(mapping243_hashtag__var_910))))) && ((v__1232.subrange::<25, 27, 2>() == BitVector::<2>::new(0b01)) && (v__1232.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000111))))} => {let mapping239_hashtag_: BitVector<5> = v__1232.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping243_hashtag_: BitVector<5> = v__1232.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping242_hashtag_: BitVector<3> = v__1232.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                let mapping241_hashtag_: BitVector<5> = v__1232.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping240_hashtag_: BitVector<5> = v__1232.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                let mapping239_hashtag_: BitVector<5> = v__1232.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping239_hashtag_), encdec_freg_backwards(mapping240_hashtag_), encdec_freg_backwards(mapping241_hashtag_), encdec_rounding_mode_backwards(mapping242_hashtag_), encdec_freg_backwards(mapping243_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                    (rs3, rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FMSUB_D)))}
                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                    v__1229 if {let mapping244_hashtag__var_903: BitVector<5> = v__1229.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping248_hashtag__var_904: BitVector<5> = v__1229.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping247_hashtag__var_905: BitVector<3> = v__1229.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                    let mapping246_hashtag__var_906: BitVector<5> = v__1229.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping245_hashtag__var_907: BitVector<5> = v__1229.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping244_hashtag__var_908: BitVector<5> = v__1229.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping244_hashtag__var_908) && (encdec_freg_backwards_matches(mapping245_hashtag__var_907) && (encdec_freg_backwards_matches(mapping246_hashtag__var_906) && (encdec_rounding_mode_backwards_matches(mapping247_hashtag__var_905) && encdec_freg_backwards_matches(mapping248_hashtag__var_904))))) && ((v__1229.subrange::<25, 27, 2>() == BitVector::<2>::new(0b01)) && (v__1229.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001011))))} => {let mapping244_hashtag_: BitVector<5> = v__1229.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping248_hashtag_: BitVector<5> = v__1229.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping247_hashtag_: BitVector<3> = v__1229.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                    let mapping246_hashtag_: BitVector<5> = v__1229.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping245_hashtag_: BitVector<5> = v__1229.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                    let mapping244_hashtag_: BitVector<5> = v__1229.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping244_hashtag_), encdec_freg_backwards(mapping245_hashtag_), encdec_freg_backwards(mapping246_hashtag_), encdec_rounding_mode_backwards(mapping247_hashtag_), encdec_freg_backwards(mapping248_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                        (rs3, rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FNMSUB_D)))}
                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                        v__1226 if {let mapping249_hashtag__var_897: BitVector<5> = v__1226.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping253_hashtag__var_898: BitVector<5> = v__1226.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping252_hashtag__var_899: BitVector<3> = v__1226.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                        let mapping251_hashtag__var_900: BitVector<5> = v__1226.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping250_hashtag__var_901: BitVector<5> = v__1226.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping249_hashtag__var_902: BitVector<5> = v__1226.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping249_hashtag__var_902) && (encdec_freg_backwards_matches(mapping250_hashtag__var_901) && (encdec_freg_backwards_matches(mapping251_hashtag__var_900) && (encdec_rounding_mode_backwards_matches(mapping252_hashtag__var_899) && encdec_freg_backwards_matches(mapping253_hashtag__var_898))))) && ((v__1226.subrange::<25, 27, 2>() == BitVector::<2>::new(0b01)) && (v__1226.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001111))))} => {let mapping249_hashtag_: BitVector<5> = v__1226.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping253_hashtag_: BitVector<5> = v__1226.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping252_hashtag_: BitVector<3> = v__1226.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                        let mapping251_hashtag_: BitVector<5> = v__1226.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping250_hashtag_: BitVector<5> = v__1226.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                        let mapping249_hashtag_: BitVector<5> = v__1226.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping249_hashtag_), encdec_freg_backwards(mapping250_hashtag_), encdec_freg_backwards(mapping251_hashtag_), encdec_rounding_mode_backwards(mapping252_hashtag_), encdec_freg_backwards(mapping253_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                            (rs3, rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, f_madd_op_D::FNMADD_D)))}
                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                            v__1223 if {let mapping257_hashtag__var_893: BitVector<5> = v__1223.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                            let mapping256_hashtag__var_894: BitVector<3> = v__1223.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                            let mapping255_hashtag__var_895: BitVector<5> = v__1223.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                            let mapping254_hashtag__var_896: BitVector<5> = v__1223.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping254_hashtag__var_896) && (encdec_freg_backwards_matches(mapping255_hashtag__var_895) && (encdec_rounding_mode_backwards_matches(mapping256_hashtag__var_894) && encdec_freg_backwards_matches(mapping257_hashtag__var_893)))) && ((v__1223.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000001)) && (v__1223.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping257_hashtag_: BitVector<5> = v__1223.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                            let mapping256_hashtag_: BitVector<3> = v__1223.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                            let mapping255_hashtag_: BitVector<5> = v__1223.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                            let mapping254_hashtag_: BitVector<5> = v__1223.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping254_hashtag_), encdec_freg_backwards(mapping255_hashtag_), encdec_rounding_mode_backwards(mapping256_hashtag_), encdec_freg_backwards(mapping257_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FADD_D)))}
                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                v__1220 if {let mapping261_hashtag__var_889: BitVector<5> = v__1220.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                let mapping260_hashtag__var_890: BitVector<3> = v__1220.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                let mapping259_hashtag__var_891: BitVector<5> = v__1220.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                let mapping258_hashtag__var_892: BitVector<5> = v__1220.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping258_hashtag__var_892) && (encdec_freg_backwards_matches(mapping259_hashtag__var_891) && (encdec_rounding_mode_backwards_matches(mapping260_hashtag__var_890) && encdec_freg_backwards_matches(mapping261_hashtag__var_889)))) && ((v__1220.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && (v__1220.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping261_hashtag_: BitVector<5> = v__1220.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                let mapping260_hashtag_: BitVector<3> = v__1220.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                let mapping259_hashtag_: BitVector<5> = v__1220.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                let mapping258_hashtag_: BitVector<5> = v__1220.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping258_hashtag_), encdec_freg_backwards(mapping259_hashtag_), encdec_rounding_mode_backwards(mapping260_hashtag_), encdec_freg_backwards(mapping261_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FSUB_D)))}
                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                    v__1217 if {let mapping265_hashtag__var_885: BitVector<5> = v__1217.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                    let mapping264_hashtag__var_886: BitVector<3> = v__1217.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                    let mapping263_hashtag__var_887: BitVector<5> = v__1217.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                    let mapping262_hashtag__var_888: BitVector<5> = v__1217.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping262_hashtag__var_888) && (encdec_freg_backwards_matches(mapping263_hashtag__var_887) && (encdec_rounding_mode_backwards_matches(mapping264_hashtag__var_886) && encdec_freg_backwards_matches(mapping265_hashtag__var_885)))) && ((v__1217.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001001)) && (v__1217.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping265_hashtag_: BitVector<5> = v__1217.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                    let mapping264_hashtag_: BitVector<3> = v__1217.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                    let mapping263_hashtag_: BitVector<5> = v__1217.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                    let mapping262_hashtag_: BitVector<5> = v__1217.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping262_hashtag_), encdec_freg_backwards(mapping263_hashtag_), encdec_rounding_mode_backwards(mapping264_hashtag_), encdec_freg_backwards(mapping265_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FMUL_D)))}
                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                        v__1214 if {let mapping269_hashtag__var_881: BitVector<5> = v__1214.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                        let mapping268_hashtag__var_882: BitVector<3> = v__1214.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                        let mapping267_hashtag__var_883: BitVector<5> = v__1214.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                        let mapping266_hashtag__var_884: BitVector<5> = v__1214.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping266_hashtag__var_884) && (encdec_freg_backwards_matches(mapping267_hashtag__var_883) && (encdec_rounding_mode_backwards_matches(mapping268_hashtag__var_882) && encdec_freg_backwards_matches(mapping269_hashtag__var_881)))) && ((v__1214.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001101)) && (v__1214.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping269_hashtag_: BitVector<5> = v__1214.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                        let mapping268_hashtag_: BitVector<3> = v__1214.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                        let mapping267_hashtag_: BitVector<5> = v__1214.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                        let mapping266_hashtag_: BitVector<5> = v__1214.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping266_hashtag_), encdec_freg_backwards(mapping267_hashtag_), encdec_rounding_mode_backwards(mapping268_hashtag_), encdec_freg_backwards(mapping269_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, f_bin_rm_op_D::FDIV_D)))}
                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                            v__1210 if {let mapping272_hashtag__var_878: BitVector<5> = v__1210.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                            let mapping271_hashtag__var_879: BitVector<3> = v__1210.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                            let mapping270_hashtag__var_880: BitVector<5> = v__1210.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping270_hashtag__var_880) && (encdec_rounding_mode_backwards_matches(mapping271_hashtag__var_879) && encdec_freg_backwards_matches(mapping272_hashtag__var_878))) && ((v__1210.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010110100000)) && (v__1210.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping272_hashtag_: BitVector<5> = v__1210.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                            let mapping271_hashtag_: BitVector<3> = v__1210.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                            let mapping270_hashtag_: BitVector<5> = v__1210.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping270_hashtag_), encdec_rounding_mode_backwards(mapping271_hashtag_), encdec_freg_backwards(mapping272_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FSQRT_D)))}
                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                v__1206 if {let mapping275_hashtag__var_875: BitVector<5> = v__1206.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                let mapping274_hashtag__var_876: BitVector<3> = v__1206.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                let mapping273_hashtag__var_877: BitVector<5> = v__1206.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping273_hashtag__var_877) && (encdec_rounding_mode_backwards_matches(mapping274_hashtag__var_876) && encdec_reg_backwards_matches(mapping275_hashtag__var_875))) && ((v__1206.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000100000)) && (v__1206.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping275_hashtag_: BitVector<5> = v__1206.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                let mapping274_hashtag_: BitVector<3> = v__1206.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                let mapping273_hashtag_: BitVector<5> = v__1206.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping273_hashtag_), encdec_rounding_mode_backwards(mapping274_hashtag_), encdec_reg_backwards(mapping275_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_W_D)))}
                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                    v__1202 if {let mapping278_hashtag__var_872: BitVector<5> = v__1202.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                    let mapping277_hashtag__var_873: BitVector<3> = v__1202.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                    let mapping276_hashtag__var_874: BitVector<5> = v__1202.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping276_hashtag__var_874) && (encdec_rounding_mode_backwards_matches(mapping277_hashtag__var_873) && encdec_reg_backwards_matches(mapping278_hashtag__var_872))) && ((v__1202.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000100001)) && (v__1202.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping278_hashtag_: BitVector<5> = v__1202.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                    let mapping277_hashtag_: BitVector<3> = v__1202.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                    let mapping276_hashtag_: BitVector<5> = v__1202.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping276_hashtag_), encdec_rounding_mode_backwards(mapping277_hashtag_), encdec_reg_backwards(mapping278_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_WU_D)))}
                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                        v__1198 if {let mapping281_hashtag__var_869: BitVector<5> = v__1198.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                        let mapping280_hashtag__var_870: BitVector<3> = v__1198.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                        let mapping279_hashtag__var_871: BitVector<5> = v__1198.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping279_hashtag__var_871) && (encdec_rounding_mode_backwards_matches(mapping280_hashtag__var_870) && encdec_freg_backwards_matches(mapping281_hashtag__var_869))) && ((v__1198.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100100000)) && (v__1198.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping281_hashtag_: BitVector<5> = v__1198.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                        let mapping280_hashtag_: BitVector<3> = v__1198.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                        let mapping279_hashtag_: BitVector<5> = v__1198.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping279_hashtag_), encdec_rounding_mode_backwards(mapping280_hashtag_), encdec_freg_backwards(mapping281_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_W)))}
                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                            v__1194 if {let mapping284_hashtag__var_866: BitVector<5> = v__1194.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                            let mapping283_hashtag__var_867: BitVector<3> = v__1194.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                            let mapping282_hashtag__var_868: BitVector<5> = v__1194.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping282_hashtag__var_868) && (encdec_rounding_mode_backwards_matches(mapping283_hashtag__var_867) && encdec_freg_backwards_matches(mapping284_hashtag__var_866))) && ((v__1194.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100100001)) && (v__1194.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping284_hashtag_: BitVector<5> = v__1194.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                            let mapping283_hashtag_: BitVector<3> = v__1194.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                            let mapping282_hashtag_: BitVector<5> = v__1194.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping282_hashtag_), encdec_rounding_mode_backwards(mapping283_hashtag_), encdec_freg_backwards(mapping284_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_WU)))}
                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                v__1190 if {let mapping287_hashtag__var_863: BitVector<5> = v__1190.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                let mapping286_hashtag__var_864: BitVector<3> = v__1190.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                let mapping285_hashtag__var_865: BitVector<5> = v__1190.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping285_hashtag__var_865) && (encdec_rounding_mode_backwards_matches(mapping286_hashtag__var_864) && encdec_freg_backwards_matches(mapping287_hashtag__var_863))) && ((v__1190.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000000001)) && (v__1190.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping287_hashtag_: BitVector<5> = v__1190.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                let mapping286_hashtag_: BitVector<3> = v__1190.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                let mapping285_hashtag_: BitVector<5> = v__1190.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping285_hashtag_), encdec_rounding_mode_backwards(mapping286_hashtag_), encdec_freg_backwards(mapping287_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_S_D)))}
                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                    v__1186 if {let mapping290_hashtag__var_860: BitVector<5> = v__1186.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                    let mapping289_hashtag__var_861: BitVector<3> = v__1186.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                    let mapping288_hashtag__var_862: BitVector<5> = v__1186.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping288_hashtag__var_862) && (encdec_rounding_mode_backwards_matches(mapping289_hashtag__var_861) && encdec_freg_backwards_matches(mapping290_hashtag__var_860))) && ((v__1186.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100000)) && (v__1186.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping290_hashtag_: BitVector<5> = v__1186.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                    let mapping289_hashtag_: BitVector<3> = v__1186.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                    let mapping288_hashtag_: BitVector<5> = v__1186.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping288_hashtag_), encdec_rounding_mode_backwards(mapping289_hashtag_), encdec_freg_backwards(mapping290_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_D_S)))}
                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                        v__1182 if {let mapping293_hashtag__var_857: BitVector<5> = v__1182.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                        let mapping292_hashtag__var_858: BitVector<3> = v__1182.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                        let mapping291_hashtag__var_859: BitVector<5> = v__1182.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping291_hashtag__var_859) && (encdec_rounding_mode_backwards_matches(mapping292_hashtag__var_858) && encdec_reg_backwards_matches(mapping293_hashtag__var_857))) && ((v__1182.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000100010)) && (v__1182.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping293_hashtag_: BitVector<5> = v__1182.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                        let mapping292_hashtag_: BitVector<3> = v__1182.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                        let mapping291_hashtag_: BitVector<5> = v__1182.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping291_hashtag_), encdec_rounding_mode_backwards(mapping292_hashtag_), encdec_reg_backwards(mapping293_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_L_D)))}
                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                            v__1178 if {let mapping296_hashtag__var_854: BitVector<5> = v__1178.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                            let mapping295_hashtag__var_855: BitVector<3> = v__1178.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                            let mapping294_hashtag__var_856: BitVector<5> = v__1178.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping294_hashtag__var_856) && (encdec_rounding_mode_backwards_matches(mapping295_hashtag__var_855) && encdec_reg_backwards_matches(mapping296_hashtag__var_854))) && ((v__1178.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000100011)) && (v__1178.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping296_hashtag_: BitVector<5> = v__1178.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                            let mapping295_hashtag_: BitVector<3> = v__1178.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                            let mapping294_hashtag_: BitVector<5> = v__1178.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping294_hashtag_), encdec_rounding_mode_backwards(mapping295_hashtag_), encdec_reg_backwards(mapping296_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_LU_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                v__1174 if {let mapping299_hashtag__var_851: BitVector<5> = v__1174.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                let mapping298_hashtag__var_852: BitVector<3> = v__1174.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                let mapping297_hashtag__var_853: BitVector<5> = v__1174.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping297_hashtag__var_853) && (encdec_rounding_mode_backwards_matches(mapping298_hashtag__var_852) && encdec_freg_backwards_matches(mapping299_hashtag__var_851))) && ((v__1174.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100100010)) && (v__1174.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping299_hashtag_: BitVector<5> = v__1174.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                let mapping298_hashtag_: BitVector<3> = v__1174.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                let mapping297_hashtag_: BitVector<5> = v__1174.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping297_hashtag_), encdec_rounding_mode_backwards(mapping298_hashtag_), encdec_freg_backwards(mapping299_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_L)))}
                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                    v__1170 if {let mapping302_hashtag__var_848: BitVector<5> = v__1170.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                    let mapping301_hashtag__var_849: BitVector<3> = v__1170.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                    let mapping300_hashtag__var_850: BitVector<5> = v__1170.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping300_hashtag__var_850) && (encdec_rounding_mode_backwards_matches(mapping301_hashtag__var_849) && encdec_freg_backwards_matches(mapping302_hashtag__var_848))) && ((v__1170.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110100100011)) && (v__1170.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping302_hashtag_: BitVector<5> = v__1170.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                    let mapping301_hashtag_: BitVector<3> = v__1170.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                    let mapping300_hashtag_: BitVector<5> = v__1170.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping300_hashtag_), encdec_rounding_mode_backwards(mapping301_hashtag_), encdec_freg_backwards(mapping302_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_LU)))}
                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                        v__1166 if {let mapping305_hashtag__var_845: BitVector<5> = v__1166.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        let mapping304_hashtag__var_846: BitVector<5> = v__1166.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        let mapping303_hashtag__var_847: BitVector<5> = v__1166.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping303_hashtag__var_847) && (encdec_freg_backwards_matches(mapping304_hashtag__var_846) && encdec_freg_backwards_matches(mapping305_hashtag__var_845))) && ((v__1166.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010001)) && ((v__1166.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1166.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping305_hashtag_: BitVector<5> = v__1166.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        let mapping304_hashtag_: BitVector<5> = v__1166.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        let mapping303_hashtag_: BitVector<5> = v__1166.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping303_hashtag_), encdec_freg_backwards(mapping304_hashtag_), encdec_freg_backwards(mapping305_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJ_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                            v__1162 if {let mapping308_hashtag__var_842: BitVector<5> = v__1162.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            let mapping307_hashtag__var_843: BitVector<5> = v__1162.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            let mapping306_hashtag__var_844: BitVector<5> = v__1162.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping306_hashtag__var_844) && (encdec_freg_backwards_matches(mapping307_hashtag__var_843) && encdec_freg_backwards_matches(mapping308_hashtag__var_842))) && ((v__1162.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010001)) && ((v__1162.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1162.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping308_hashtag_: BitVector<5> = v__1162.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            let mapping307_hashtag_: BitVector<5> = v__1162.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            let mapping306_hashtag_: BitVector<5> = v__1162.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping306_hashtag_), encdec_freg_backwards(mapping307_hashtag_), encdec_freg_backwards(mapping308_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJN_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                v__1158 if {let mapping311_hashtag__var_839: BitVector<5> = v__1158.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                let mapping310_hashtag__var_840: BitVector<5> = v__1158.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                let mapping309_hashtag__var_841: BitVector<5> = v__1158.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping309_hashtag__var_841) && (encdec_freg_backwards_matches(mapping310_hashtag__var_840) && encdec_freg_backwards_matches(mapping311_hashtag__var_839))) && ((v__1158.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010001)) && ((v__1158.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1158.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping311_hashtag_: BitVector<5> = v__1158.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                let mapping310_hashtag_: BitVector<5> = v__1158.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                let mapping309_hashtag_: BitVector<5> = v__1158.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping309_hashtag_), encdec_freg_backwards(mapping310_hashtag_), encdec_freg_backwards(mapping311_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJX_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                    v__1154 if {let mapping314_hashtag__var_836: BitVector<5> = v__1154.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping313_hashtag__var_837: BitVector<5> = v__1154.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping312_hashtag__var_838: BitVector<5> = v__1154.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping312_hashtag__var_838) && (encdec_freg_backwards_matches(mapping313_hashtag__var_837) && encdec_freg_backwards_matches(mapping314_hashtag__var_836))) && ((v__1154.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010101)) && ((v__1154.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1154.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping314_hashtag_: BitVector<5> = v__1154.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping313_hashtag_: BitVector<5> = v__1154.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping312_hashtag_: BitVector<5> = v__1154.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping312_hashtag_), encdec_freg_backwards(mapping313_hashtag_), encdec_freg_backwards(mapping314_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMIN_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                        v__1150 if {let mapping317_hashtag__var_833: BitVector<5> = v__1150.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping316_hashtag__var_834: BitVector<5> = v__1150.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping315_hashtag__var_835: BitVector<5> = v__1150.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping315_hashtag__var_835) && (encdec_freg_backwards_matches(mapping316_hashtag__var_834) && encdec_freg_backwards_matches(mapping317_hashtag__var_833))) && ((v__1150.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010101)) && ((v__1150.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1150.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping317_hashtag_: BitVector<5> = v__1150.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping316_hashtag_: BitVector<5> = v__1150.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping315_hashtag_: BitVector<5> = v__1150.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping315_hashtag_), encdec_freg_backwards(mapping316_hashtag_), encdec_freg_backwards(mapping317_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMAX_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                            v__1146 if {let mapping320_hashtag__var_830: BitVector<5> = v__1146.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping319_hashtag__var_831: BitVector<5> = v__1146.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping318_hashtag__var_832: BitVector<5> = v__1146.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping318_hashtag__var_832) && (encdec_freg_backwards_matches(mapping319_hashtag__var_831) && encdec_reg_backwards_matches(mapping320_hashtag__var_830))) && ((v__1146.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010001)) && ((v__1146.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1146.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping320_hashtag_: BitVector<5> = v__1146.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping319_hashtag_: BitVector<5> = v__1146.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping318_hashtag_: BitVector<5> = v__1146.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping318_hashtag_), encdec_freg_backwards(mapping319_hashtag_), encdec_reg_backwards(mapping320_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FEQ_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                v__1142 if {let mapping323_hashtag__var_827: BitVector<5> = v__1142.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping322_hashtag__var_828: BitVector<5> = v__1142.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping321_hashtag__var_829: BitVector<5> = v__1142.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping321_hashtag__var_829) && (encdec_freg_backwards_matches(mapping322_hashtag__var_828) && encdec_reg_backwards_matches(mapping323_hashtag__var_827))) && ((v__1142.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010001)) && ((v__1142.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1142.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping323_hashtag_: BitVector<5> = v__1142.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping322_hashtag_: BitVector<5> = v__1142.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping321_hashtag_: BitVector<5> = v__1142.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping321_hashtag_), encdec_freg_backwards(mapping322_hashtag_), encdec_reg_backwards(mapping323_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLT_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1138 if {let mapping326_hashtag__var_824: BitVector<5> = v__1138.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping325_hashtag__var_825: BitVector<5> = v__1138.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping324_hashtag__var_826: BitVector<5> = v__1138.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping324_hashtag__var_826) && (encdec_freg_backwards_matches(mapping325_hashtag__var_825) && encdec_reg_backwards_matches(mapping326_hashtag__var_824))) && ((v__1138.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010001)) && ((v__1138.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1138.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping326_hashtag_: BitVector<5> = v__1138.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping325_hashtag_: BitVector<5> = v__1138.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping324_hashtag_: BitVector<5> = v__1138.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping324_hashtag_), encdec_freg_backwards(mapping325_hashtag_), encdec_reg_backwards(mapping326_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLE_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1133 if {let mapping328_hashtag__var_822: BitVector<5> = v__1133.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping327_hashtag__var_823: BitVector<5> = v__1133.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping327_hashtag__var_823) && encdec_reg_backwards_matches(mapping328_hashtag__var_822)) && ((v__1133.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111000100000)) && ((v__1133.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1133.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping328_hashtag_: BitVector<5> = v__1133.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping327_hashtag_: BitVector<5> = v__1133.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping327_hashtag_), encdec_reg_backwards(mapping328_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {haveDoubleFPU(core_ctx, ())} => {Some(ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FCLASS_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1128 if {let mapping330_hashtag__var_820: BitVector<5> = v__1128.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping329_hashtag__var_821: BitVector<5> = v__1128.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping329_hashtag__var_821) && encdec_reg_backwards_matches(mapping330_hashtag__var_820)) && ((v__1128.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111000100000)) && ((v__1128.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1128.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping330_hashtag_: BitVector<5> = v__1128.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping329_hashtag_: BitVector<5> = v__1128.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping329_hashtag_), encdec_reg_backwards(mapping330_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {Some(ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FMV_X_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1123 if {let mapping332_hashtag__var_818: BitVector<5> = v__1123.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping331_hashtag__var_819: BitVector<5> = v__1123.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping331_hashtag__var_819) && encdec_freg_backwards_matches(mapping332_hashtag__var_818)) && ((v__1123.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111100100000)) && ((v__1123.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1123.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping332_hashtag_: BitVector<5> = v__1123.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping331_hashtag_: BitVector<5> = v__1123.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping331_hashtag_), encdec_freg_backwards(mapping332_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_D)} => {Some(ast::F_UN_F_TYPE_D((rs1, rd, f_un_f_op_D::FMV_D_X)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1118 if {let mapping334_hashtag__var_816: BitVector<5> = v__1118.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping333_hashtag__var_817: BitVector<5> = v__1118.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping333_hashtag__var_817) && encdec_reg_backwards_matches(mapping334_hashtag__var_816)) && ((v__1118.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001011)) && (v__1118.subrange::<0, 15, 15>() == BitVector::<15>::new(0b000000001110011))))} => {let mapping334_hashtag_: BitVector<5> = v__1118.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping333_hashtag_: BitVector<5> = v__1118.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping333_hashtag_), encdec_reg_backwards(mapping334_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1) if {currentlyEnabled(core_ctx, extension::Ext_Svinval)} => {Some(ast::SINVAL_VMA((rs1, rs2)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1100 if {(currentlyEnabled(core_ctx, extension::Ext_Svinval) && (v__1100 == BitVector::<32>::new(0b00011000000000000000000001110011)))} => {Some(ast::SFENCE_W_INVAL(()))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1107 if {(currentlyEnabled(core_ctx, extension::Ext_Svinval) && (v__1107 == BitVector::<32>::new(0b00011000000100000000000001110011)))} => {Some(ast::SFENCE_INVAL_IR(()))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1114 if {let mapping336_hashtag__var_814: BitVector<5> = v__1114.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping335_hashtag__var_815: BitVector<5> = v__1114.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping335_hashtag__var_815) && encdec_reg_backwards_matches(mapping336_hashtag__var_814)) && ((v__1114.subrange::<26, 32, 6>() == BitVector::<6>::new(0b000010)) && ((v__1114.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1114.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let shamt: BitVector<6> = v__1114.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping336_hashtag_: BitVector<5> = v__1114.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping335_hashtag_: BitVector<5> = v__1114.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping335_hashtag_), encdec_reg_backwards(mapping336_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::SLLIUW((shamt, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1096 if {let mapping339_hashtag__var_811: BitVector<5> = v__1096.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping338_hashtag__var_812: BitVector<5> = v__1096.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping337_hashtag__var_813: BitVector<5> = v__1096.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping337_hashtag__var_813) && (encdec_reg_backwards_matches(mapping338_hashtag__var_812) && encdec_reg_backwards_matches(mapping339_hashtag__var_811))) && ((v__1096.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000100)) && ((v__1096.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__1096.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping339_hashtag_: BitVector<5> = v__1096.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping338_hashtag_: BitVector<5> = v__1096.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping337_hashtag_: BitVector<5> = v__1096.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping337_hashtag_), encdec_reg_backwards(mapping338_hashtag_), encdec_reg_backwards(mapping339_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::ADDUW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1092 if {let mapping342_hashtag__var_808: BitVector<5> = v__1092.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping341_hashtag__var_809: BitVector<5> = v__1092.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping340_hashtag__var_810: BitVector<5> = v__1092.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping340_hashtag__var_810) && (encdec_reg_backwards_matches(mapping341_hashtag__var_809) && encdec_reg_backwards_matches(mapping342_hashtag__var_808))) && ((v__1092.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1092.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1092.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping342_hashtag_: BitVector<5> = v__1092.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping341_hashtag_: BitVector<5> = v__1092.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping340_hashtag_: BitVector<5> = v__1092.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping340_hashtag_), encdec_reg_backwards(mapping341_hashtag_), encdec_reg_backwards(mapping342_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH1ADDUW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1088 if {let mapping345_hashtag__var_805: BitVector<5> = v__1088.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping344_hashtag__var_806: BitVector<5> = v__1088.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping343_hashtag__var_807: BitVector<5> = v__1088.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping343_hashtag__var_807) && (encdec_reg_backwards_matches(mapping344_hashtag__var_806) && encdec_reg_backwards_matches(mapping345_hashtag__var_805))) && ((v__1088.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1088.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1088.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping345_hashtag_: BitVector<5> = v__1088.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping344_hashtag_: BitVector<5> = v__1088.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping343_hashtag_: BitVector<5> = v__1088.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping343_hashtag_), encdec_reg_backwards(mapping344_hashtag_), encdec_reg_backwards(mapping345_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH2ADDUW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1084 if {let mapping348_hashtag__var_802: BitVector<5> = v__1084.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping347_hashtag__var_803: BitVector<5> = v__1084.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping346_hashtag__var_804: BitVector<5> = v__1084.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping346_hashtag__var_804) && (encdec_reg_backwards_matches(mapping347_hashtag__var_803) && encdec_reg_backwards_matches(mapping348_hashtag__var_802))) && ((v__1084.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1084.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__1084.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping348_hashtag_: BitVector<5> = v__1084.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping347_hashtag_: BitVector<5> = v__1084.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping346_hashtag_: BitVector<5> = v__1084.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping346_hashtag_), encdec_reg_backwards(mapping347_hashtag_), encdec_reg_backwards(mapping348_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPEUW((rs2, rs1, rd, bropw_zba::SH3ADDUW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1080 if {let mapping351_hashtag__var_799: BitVector<5> = v__1080.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping350_hashtag__var_800: BitVector<5> = v__1080.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping349_hashtag__var_801: BitVector<5> = v__1080.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping349_hashtag__var_801) && (encdec_reg_backwards_matches(mapping350_hashtag__var_800) && encdec_reg_backwards_matches(mapping351_hashtag__var_799))) && ((v__1080.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1080.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__1080.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping351_hashtag_: BitVector<5> = v__1080.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping350_hashtag_: BitVector<5> = v__1080.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping349_hashtag_: BitVector<5> = v__1080.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping349_hashtag_), encdec_reg_backwards(mapping350_hashtag_), encdec_reg_backwards(mapping351_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH1ADD)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1076 if {let mapping354_hashtag__var_796: BitVector<5> = v__1076.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping353_hashtag__var_797: BitVector<5> = v__1076.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping352_hashtag__var_798: BitVector<5> = v__1076.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping352_hashtag__var_798) && (encdec_reg_backwards_matches(mapping353_hashtag__var_797) && encdec_reg_backwards_matches(mapping354_hashtag__var_796))) && ((v__1076.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1076.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1076.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping354_hashtag_: BitVector<5> = v__1076.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping353_hashtag_: BitVector<5> = v__1076.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping352_hashtag_: BitVector<5> = v__1076.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping352_hashtag_), encdec_reg_backwards(mapping353_hashtag_), encdec_reg_backwards(mapping354_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH2ADD)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1072 if {let mapping357_hashtag__var_793: BitVector<5> = v__1072.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping356_hashtag__var_794: BitVector<5> = v__1072.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping355_hashtag__var_795: BitVector<5> = v__1072.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping355_hashtag__var_795) && (encdec_reg_backwards_matches(mapping356_hashtag__var_794) && encdec_reg_backwards_matches(mapping357_hashtag__var_793))) && ((v__1072.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010000)) && ((v__1072.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__1072.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping357_hashtag_: BitVector<5> = v__1072.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping356_hashtag_: BitVector<5> = v__1072.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping355_hashtag_: BitVector<5> = v__1072.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping355_hashtag_), encdec_reg_backwards(mapping356_hashtag_), encdec_reg_backwards(mapping357_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zba)} => {Some(ast::ZBA_RTYPE((rs2, rs1, rd, brop_zba::SH3ADD)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1068 if {let mapping359_hashtag__var_791: BitVector<5> = v__1068.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping358_hashtag__var_792: BitVector<5> = v__1068.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping358_hashtag__var_792) && encdec_reg_backwards_matches(mapping359_hashtag__var_791)) && ((v__1068.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110000)) && ((v__1068.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1068.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let shamt: BitVector<5> = v__1068.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping359_hashtag_: BitVector<5> = v__1068.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping358_hashtag_: BitVector<5> = v__1068.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping358_hashtag_), encdec_reg_backwards(mapping359_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::RORIW((shamt, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1064 if {let mapping361_hashtag__var_789: BitVector<5> = v__1064.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping360_hashtag__var_790: BitVector<5> = v__1064.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping360_hashtag__var_790) && encdec_reg_backwards_matches(mapping361_hashtag__var_789)) && ((v__1064.subrange::<26, 32, 6>() == BitVector::<6>::new(0b011000)) && ((v__1064.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1064.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__1064.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping361_hashtag_: BitVector<5> = v__1064.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping360_hashtag_: BitVector<5> = v__1064.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping360_hashtag_), encdec_reg_backwards(mapping361_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::RORI((shamt, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1060 if {let mapping364_hashtag__var_786: BitVector<5> = v__1060.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping363_hashtag__var_787: BitVector<5> = v__1060.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping362_hashtag__var_788: BitVector<5> = v__1060.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping362_hashtag__var_788) && (encdec_reg_backwards_matches(mapping363_hashtag__var_787) && encdec_reg_backwards_matches(mapping364_hashtag__var_786))) && ((v__1060.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110000)) && ((v__1060.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1060.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping364_hashtag_: BitVector<5> = v__1060.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping363_hashtag_: BitVector<5> = v__1060.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping362_hashtag_: BitVector<5> = v__1060.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping362_hashtag_), encdec_reg_backwards(mapping363_hashtag_), encdec_reg_backwards(mapping364_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPEW((rs2, rs1, rd, bropw_zbb::ROLW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1056 if {let mapping367_hashtag__var_783: BitVector<5> = v__1056.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping366_hashtag__var_784: BitVector<5> = v__1056.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping365_hashtag__var_785: BitVector<5> = v__1056.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping365_hashtag__var_785) && (encdec_reg_backwards_matches(mapping366_hashtag__var_784) && encdec_reg_backwards_matches(mapping367_hashtag__var_783))) && ((v__1056.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110000)) && ((v__1056.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1056.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping367_hashtag_: BitVector<5> = v__1056.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping366_hashtag_: BitVector<5> = v__1056.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping365_hashtag_: BitVector<5> = v__1056.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping365_hashtag_), encdec_reg_backwards(mapping366_hashtag_), encdec_reg_backwards(mapping367_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPEW((rs2, rs1, rd, bropw_zbb::RORW)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1052 if {let mapping370_hashtag__var_780: BitVector<5> = v__1052.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping369_hashtag__var_781: BitVector<5> = v__1052.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping368_hashtag__var_782: BitVector<5> = v__1052.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping368_hashtag__var_782) && (encdec_reg_backwards_matches(mapping369_hashtag__var_781) && encdec_reg_backwards_matches(mapping370_hashtag__var_780))) && ((v__1052.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1052.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__1052.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping370_hashtag_: BitVector<5> = v__1052.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping369_hashtag_: BitVector<5> = v__1052.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping368_hashtag_: BitVector<5> = v__1052.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping368_hashtag_), encdec_reg_backwards(mapping369_hashtag_), encdec_reg_backwards(mapping370_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ANDN)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1048 if {let mapping373_hashtag__var_777: BitVector<5> = v__1048.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping372_hashtag__var_778: BitVector<5> = v__1048.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping371_hashtag__var_779: BitVector<5> = v__1048.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping371_hashtag__var_779) && (encdec_reg_backwards_matches(mapping372_hashtag__var_778) && encdec_reg_backwards_matches(mapping373_hashtag__var_777))) && ((v__1048.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1048.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__1048.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping373_hashtag_: BitVector<5> = v__1048.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping372_hashtag_: BitVector<5> = v__1048.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping371_hashtag_: BitVector<5> = v__1048.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping371_hashtag_), encdec_reg_backwards(mapping372_hashtag_), encdec_reg_backwards(mapping373_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ORN)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1044 if {let mapping376_hashtag__var_774: BitVector<5> = v__1044.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping375_hashtag__var_775: BitVector<5> = v__1044.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping374_hashtag__var_776: BitVector<5> = v__1044.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping374_hashtag__var_776) && (encdec_reg_backwards_matches(mapping375_hashtag__var_775) && encdec_reg_backwards_matches(mapping376_hashtag__var_774))) && ((v__1044.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100000)) && ((v__1044.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1044.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping376_hashtag_: BitVector<5> = v__1044.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping375_hashtag_: BitVector<5> = v__1044.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping374_hashtag_: BitVector<5> = v__1044.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping374_hashtag_), encdec_reg_backwards(mapping375_hashtag_), encdec_reg_backwards(mapping376_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::XNOR)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1040 if {let mapping379_hashtag__var_771: BitVector<5> = v__1040.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping378_hashtag__var_772: BitVector<5> = v__1040.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping377_hashtag__var_773: BitVector<5> = v__1040.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping377_hashtag__var_773) && (encdec_reg_backwards_matches(mapping378_hashtag__var_772) && encdec_reg_backwards_matches(mapping379_hashtag__var_771))) && ((v__1040.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__1040.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__1040.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping379_hashtag_: BitVector<5> = v__1040.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping378_hashtag_: BitVector<5> = v__1040.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping377_hashtag_: BitVector<5> = v__1040.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping377_hashtag_), encdec_reg_backwards(mapping378_hashtag_), encdec_reg_backwards(mapping379_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MAX)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1036 if {let mapping382_hashtag__var_768: BitVector<5> = v__1036.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping381_hashtag__var_769: BitVector<5> = v__1036.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping380_hashtag__var_770: BitVector<5> = v__1036.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping380_hashtag__var_770) && (encdec_reg_backwards_matches(mapping381_hashtag__var_769) && encdec_reg_backwards_matches(mapping382_hashtag__var_768))) && ((v__1036.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__1036.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__1036.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping382_hashtag_: BitVector<5> = v__1036.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping381_hashtag_: BitVector<5> = v__1036.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping380_hashtag_: BitVector<5> = v__1036.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping380_hashtag_), encdec_reg_backwards(mapping381_hashtag_), encdec_reg_backwards(mapping382_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MAXU)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1032 if {let mapping385_hashtag__var_765: BitVector<5> = v__1032.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping384_hashtag__var_766: BitVector<5> = v__1032.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping383_hashtag__var_767: BitVector<5> = v__1032.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping383_hashtag__var_767) && (encdec_reg_backwards_matches(mapping384_hashtag__var_766) && encdec_reg_backwards_matches(mapping385_hashtag__var_765))) && ((v__1032.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__1032.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1032.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping385_hashtag_: BitVector<5> = v__1032.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping384_hashtag_: BitVector<5> = v__1032.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping383_hashtag_: BitVector<5> = v__1032.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping383_hashtag_), encdec_reg_backwards(mapping384_hashtag_), encdec_reg_backwards(mapping385_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MIN)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1028 if {let mapping388_hashtag__var_762: BitVector<5> = v__1028.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping387_hashtag__var_763: BitVector<5> = v__1028.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping386_hashtag__var_764: BitVector<5> = v__1028.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping386_hashtag__var_764) && (encdec_reg_backwards_matches(mapping387_hashtag__var_763) && encdec_reg_backwards_matches(mapping388_hashtag__var_762))) && ((v__1028.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__1028.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1028.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping388_hashtag_: BitVector<5> = v__1028.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping387_hashtag_: BitVector<5> = v__1028.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping386_hashtag_: BitVector<5> = v__1028.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping386_hashtag_), encdec_reg_backwards(mapping387_hashtag_), encdec_reg_backwards(mapping388_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::MINU)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1024 if {let mapping391_hashtag__var_759: BitVector<5> = v__1024.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping390_hashtag__var_760: BitVector<5> = v__1024.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping389_hashtag__var_761: BitVector<5> = v__1024.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping389_hashtag__var_761) && (encdec_reg_backwards_matches(mapping390_hashtag__var_760) && encdec_reg_backwards_matches(mapping391_hashtag__var_759))) && ((v__1024.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110000)) && ((v__1024.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1024.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping391_hashtag_: BitVector<5> = v__1024.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping390_hashtag_: BitVector<5> = v__1024.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping389_hashtag_: BitVector<5> = v__1024.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping389_hashtag_), encdec_reg_backwards(mapping390_hashtag_), encdec_reg_backwards(mapping391_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ROL)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1020 if {let mapping394_hashtag__var_756: BitVector<5> = v__1020.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping393_hashtag__var_757: BitVector<5> = v__1020.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping392_hashtag__var_758: BitVector<5> = v__1020.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping392_hashtag__var_758) && (encdec_reg_backwards_matches(mapping393_hashtag__var_757) && encdec_reg_backwards_matches(mapping394_hashtag__var_756))) && ((v__1020.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110000)) && ((v__1020.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__1020.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping394_hashtag_: BitVector<5> = v__1020.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping393_hashtag_: BitVector<5> = v__1020.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping392_hashtag_: BitVector<5> = v__1020.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping392_hashtag_), encdec_reg_backwards(mapping393_hashtag_), encdec_reg_backwards(mapping394_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::ZBB_RTYPE((rs2, rs1, rd, brop_zbb::ROR)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__1015 if {let mapping396_hashtag__var_754: BitVector<5> = v__1015.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping395_hashtag__var_755: BitVector<5> = v__1015.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping395_hashtag__var_755) && encdec_reg_backwards_matches(mapping396_hashtag__var_754)) && ((v__1015.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000100)) && ((v__1015.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1015.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping396_hashtag_: BitVector<5> = v__1015.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping395_hashtag_: BitVector<5> = v__1015.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping395_hashtag_), encdec_reg_backwards(mapping396_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_EXTOP((rs1, rd, extop_zbb::SEXTB)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__1010 if {let mapping398_hashtag__var_752: BitVector<5> = v__1010.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping397_hashtag__var_753: BitVector<5> = v__1010.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping397_hashtag__var_753) && encdec_reg_backwards_matches(mapping398_hashtag__var_752)) && ((v__1010.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000101)) && ((v__1010.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__1010.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping398_hashtag_: BitVector<5> = v__1010.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping397_hashtag_: BitVector<5> = v__1010.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping397_hashtag_), encdec_reg_backwards(mapping398_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_EXTOP((rs1, rd, extop_zbb::SEXTH)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__1005 if {let mapping400_hashtag__var_750: BitVector<5> = v__1005.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping399_hashtag__var_751: BitVector<5> = v__1005.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping399_hashtag__var_751) && encdec_reg_backwards_matches(mapping400_hashtag__var_750)) && ((v__1005.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000010000000)) && ((v__1005.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1005.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping400_hashtag_: BitVector<5> = v__1005.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping399_hashtag_: BitVector<5> = v__1005.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__1000 if {let mapping402_hashtag__var_748: BitVector<5> = v__1000.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping401_hashtag__var_749: BitVector<5> = v__1000.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping401_hashtag__var_749) && encdec_reg_backwards_matches(mapping402_hashtag__var_748)) && ((v__1000.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000010000000)) && ((v__1000.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__1000.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping402_hashtag_: BitVector<5> = v__1000.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping401_hashtag_: BitVector<5> = v__1000.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping401_hashtag_), encdec_reg_backwards(mapping402_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ZBB_EXTOP((rs1, rd, extop_zbb::ZEXTH)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__996 if {let mapping404_hashtag__var_746: BitVector<5> = v__996.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping403_hashtag__var_747: BitVector<5> = v__996.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping403_hashtag__var_747) && encdec_reg_backwards_matches(mapping404_hashtag__var_746)) && ((v__996.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011010011000)) && ((v__996.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__996.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping404_hashtag_: BitVector<5> = v__996.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping403_hashtag_: BitVector<5> = v__996.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__992 if {let mapping406_hashtag__var_744: BitVector<5> = v__992.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping405_hashtag__var_745: BitVector<5> = v__992.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping405_hashtag__var_745) && encdec_reg_backwards_matches(mapping406_hashtag__var_744)) && ((v__992.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011010111000)) && ((v__992.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__992.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping406_hashtag_: BitVector<5> = v__992.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping405_hashtag_: BitVector<5> = v__992.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping405_hashtag_), encdec_reg_backwards(mapping406_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbb) || currentlyEnabled(core_ctx, extension::Ext_Zbkb))} => {Some(ast::REV8((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__988 if {let mapping408_hashtag__var_742: BitVector<5> = v__988.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping407_hashtag__var_743: BitVector<5> = v__988.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping407_hashtag__var_743) && encdec_reg_backwards_matches(mapping408_hashtag__var_742)) && ((v__988.subrange::<20, 32, 12>() == BitVector::<12>::new(0b001010000111)) && ((v__988.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__988.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping408_hashtag_: BitVector<5> = v__988.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping407_hashtag_: BitVector<5> = v__988.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping407_hashtag_), encdec_reg_backwards(mapping408_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::ORCB((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__984 if {let mapping410_hashtag__var_740: BitVector<5> = v__984.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping409_hashtag__var_741: BitVector<5> = v__984.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping409_hashtag__var_741) && encdec_reg_backwards_matches(mapping410_hashtag__var_740)) && ((v__984.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000010)) && ((v__984.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__984.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping410_hashtag_: BitVector<5> = v__984.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping409_hashtag_: BitVector<5> = v__984.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping409_hashtag_), encdec_reg_backwards(mapping410_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CPOP((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__980 if {let mapping412_hashtag__var_738: BitVector<5> = v__980.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping411_hashtag__var_739: BitVector<5> = v__980.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping411_hashtag__var_739) && encdec_reg_backwards_matches(mapping412_hashtag__var_738)) && ((v__980.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000010)) && ((v__980.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__980.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let mapping412_hashtag_: BitVector<5> = v__980.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping411_hashtag_: BitVector<5> = v__980.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping411_hashtag_), encdec_reg_backwards(mapping412_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CPOPW((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__976 if {let mapping414_hashtag__var_736: BitVector<5> = v__976.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping413_hashtag__var_737: BitVector<5> = v__976.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping413_hashtag__var_737) && encdec_reg_backwards_matches(mapping414_hashtag__var_736)) && ((v__976.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000000)) && ((v__976.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__976.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping414_hashtag_: BitVector<5> = v__976.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping413_hashtag_: BitVector<5> = v__976.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping413_hashtag_), encdec_reg_backwards(mapping414_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CLZ((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__972 if {let mapping416_hashtag__var_734: BitVector<5> = v__972.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping415_hashtag__var_735: BitVector<5> = v__972.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping415_hashtag__var_735) && encdec_reg_backwards_matches(mapping416_hashtag__var_734)) && ((v__972.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000000)) && ((v__972.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__972.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let mapping416_hashtag_: BitVector<5> = v__972.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping415_hashtag_: BitVector<5> = v__972.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping415_hashtag_), encdec_reg_backwards(mapping416_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CLZW((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__968 if {let mapping418_hashtag__var_732: BitVector<5> = v__968.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping417_hashtag__var_733: BitVector<5> = v__968.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping417_hashtag__var_733) && encdec_reg_backwards_matches(mapping418_hashtag__var_732)) && ((v__968.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000001)) && ((v__968.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__968.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping418_hashtag_: BitVector<5> = v__968.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping417_hashtag_: BitVector<5> = v__968.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping417_hashtag_), encdec_reg_backwards(mapping418_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CTZ((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__964 if {let mapping420_hashtag__var_730: BitVector<5> = v__964.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping419_hashtag__var_731: BitVector<5> = v__964.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping419_hashtag__var_731) && encdec_reg_backwards_matches(mapping420_hashtag__var_730)) && ((v__964.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011000000001)) && ((v__964.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__964.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0011011)))))} => {let mapping420_hashtag_: BitVector<5> = v__964.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping419_hashtag_: BitVector<5> = v__964.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping419_hashtag_), encdec_reg_backwards(mapping420_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbb)} => {Some(ast::CTZW((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__960 if {let mapping423_hashtag__var_727: BitVector<5> = v__960.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping422_hashtag__var_728: BitVector<5> = v__960.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping421_hashtag__var_729: BitVector<5> = v__960.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping421_hashtag__var_729) && (encdec_reg_backwards_matches(mapping422_hashtag__var_728) && encdec_reg_backwards_matches(mapping423_hashtag__var_727))) && ((v__960.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__960.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__960.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping423_hashtag_: BitVector<5> = v__960.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping422_hashtag_: BitVector<5> = v__960.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping421_hashtag_: BitVector<5> = v__960.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping421_hashtag_), encdec_reg_backwards(mapping422_hashtag_), encdec_reg_backwards(mapping423_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbc) || currentlyEnabled(core_ctx, extension::Ext_Zbkc))} => {Some(ast::CLMUL((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__956 if {let mapping426_hashtag__var_724: BitVector<5> = v__956.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping425_hashtag__var_725: BitVector<5> = v__956.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping424_hashtag__var_726: BitVector<5> = v__956.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping424_hashtag__var_726) && (encdec_reg_backwards_matches(mapping425_hashtag__var_725) && encdec_reg_backwards_matches(mapping426_hashtag__var_724))) && ((v__956.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__956.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__956.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping426_hashtag_: BitVector<5> = v__956.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping425_hashtag_: BitVector<5> = v__956.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping424_hashtag_: BitVector<5> = v__956.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping424_hashtag_), encdec_reg_backwards(mapping425_hashtag_), encdec_reg_backwards(mapping426_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zbc) || currentlyEnabled(core_ctx, extension::Ext_Zbkc))} => {Some(ast::CLMULH((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__952 if {let mapping429_hashtag__var_721: BitVector<5> = v__952.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping428_hashtag__var_722: BitVector<5> = v__952.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping427_hashtag__var_723: BitVector<5> = v__952.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping427_hashtag__var_723) && (encdec_reg_backwards_matches(mapping428_hashtag__var_722) && encdec_reg_backwards_matches(mapping429_hashtag__var_721))) && ((v__952.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000101)) && ((v__952.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__952.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping429_hashtag_: BitVector<5> = v__952.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping428_hashtag_: BitVector<5> = v__952.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping427_hashtag_: BitVector<5> = v__952.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping427_hashtag_), encdec_reg_backwards(mapping428_hashtag_), encdec_reg_backwards(mapping429_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbc)} => {Some(ast::CLMULR((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__948 if {let mapping431_hashtag__var_719: BitVector<5> = v__948.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping430_hashtag__var_720: BitVector<5> = v__948.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping430_hashtag__var_720) && encdec_reg_backwards_matches(mapping431_hashtag__var_719)) && ((v__948.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__948.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__948.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__948.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping431_hashtag_: BitVector<5> = v__948.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping430_hashtag_: BitVector<5> = v__948.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping430_hashtag_), encdec_reg_backwards(mapping431_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BCLRI)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__944 if {let mapping433_hashtag__var_717: BitVector<5> = v__944.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping432_hashtag__var_718: BitVector<5> = v__944.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping432_hashtag__var_718) && encdec_reg_backwards_matches(mapping433_hashtag__var_717)) && ((v__944.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__944.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__944.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__944.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping433_hashtag_: BitVector<5> = v__944.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping432_hashtag_: BitVector<5> = v__944.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping432_hashtag_), encdec_reg_backwards(mapping433_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BEXTI)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__940 if {let mapping435_hashtag__var_715: BitVector<5> = v__940.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping434_hashtag__var_716: BitVector<5> = v__940.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping434_hashtag__var_716) && encdec_reg_backwards_matches(mapping435_hashtag__var_715)) && ((v__940.subrange::<26, 32, 6>() == BitVector::<6>::new(0b011010)) && ((v__940.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__940.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__940.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping435_hashtag_: BitVector<5> = v__940.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping434_hashtag_: BitVector<5> = v__940.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping434_hashtag_), encdec_reg_backwards(mapping435_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BINVI)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__936 if {let mapping437_hashtag__var_713: BitVector<5> = v__936.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping436_hashtag__var_714: BitVector<5> = v__936.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping436_hashtag__var_714) && encdec_reg_backwards_matches(mapping437_hashtag__var_713)) && ((v__936.subrange::<26, 32, 6>() == BitVector::<6>::new(0b001010)) && ((v__936.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__936.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let shamt: BitVector<6> = v__936.subrange::<20, 26, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping437_hashtag_: BitVector<5> = v__936.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping436_hashtag_: BitVector<5> = v__936.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping436_hashtag_), encdec_reg_backwards(mapping437_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_IOP((shamt, rs1, rd, biop_zbs::BSETI)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__932 if {let mapping440_hashtag__var_710: BitVector<5> = v__932.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping439_hashtag__var_711: BitVector<5> = v__932.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping438_hashtag__var_712: BitVector<5> = v__932.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping438_hashtag__var_712) && (encdec_reg_backwards_matches(mapping439_hashtag__var_711) && encdec_reg_backwards_matches(mapping440_hashtag__var_710))) && ((v__932.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100100)) && ((v__932.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__932.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping440_hashtag_: BitVector<5> = v__932.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping439_hashtag_: BitVector<5> = v__932.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping438_hashtag_: BitVector<5> = v__932.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping438_hashtag_), encdec_reg_backwards(mapping439_hashtag_), encdec_reg_backwards(mapping440_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BCLR)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__928 if {let mapping443_hashtag__var_707: BitVector<5> = v__928.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping442_hashtag__var_708: BitVector<5> = v__928.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping441_hashtag__var_709: BitVector<5> = v__928.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping441_hashtag__var_709) && (encdec_reg_backwards_matches(mapping442_hashtag__var_708) && encdec_reg_backwards_matches(mapping443_hashtag__var_707))) && ((v__928.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100100)) && ((v__928.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__928.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping443_hashtag_: BitVector<5> = v__928.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping442_hashtag_: BitVector<5> = v__928.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping441_hashtag_: BitVector<5> = v__928.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping441_hashtag_), encdec_reg_backwards(mapping442_hashtag_), encdec_reg_backwards(mapping443_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BEXT)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__924 if {let mapping446_hashtag__var_704: BitVector<5> = v__924.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping445_hashtag__var_705: BitVector<5> = v__924.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping444_hashtag__var_706: BitVector<5> = v__924.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping444_hashtag__var_706) && (encdec_reg_backwards_matches(mapping445_hashtag__var_705) && encdec_reg_backwards_matches(mapping446_hashtag__var_704))) && ((v__924.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0110100)) && ((v__924.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__924.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping446_hashtag_: BitVector<5> = v__924.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping445_hashtag_: BitVector<5> = v__924.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping444_hashtag_: BitVector<5> = v__924.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping444_hashtag_), encdec_reg_backwards(mapping445_hashtag_), encdec_reg_backwards(mapping446_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BINV)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__920 if {let mapping449_hashtag__var_701: BitVector<5> = v__920.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping448_hashtag__var_702: BitVector<5> = v__920.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping447_hashtag__var_703: BitVector<5> = v__920.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping447_hashtag__var_703) && (encdec_reg_backwards_matches(mapping448_hashtag__var_702) && encdec_reg_backwards_matches(mapping449_hashtag__var_701))) && ((v__920.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__920.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__920.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping449_hashtag_: BitVector<5> = v__920.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping448_hashtag_: BitVector<5> = v__920.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping447_hashtag_: BitVector<5> = v__920.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping447_hashtag_), encdec_reg_backwards(mapping448_hashtag_), encdec_reg_backwards(mapping449_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbs)} => {Some(ast::ZBS_RTYPE((rs2, rs1, rd, brop_zbs::BSET)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__917 if {let mapping453_hashtag__var_697: BitVector<5> = v__917.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping452_hashtag__var_698: BitVector<3> = v__917.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping451_hashtag__var_699: BitVector<5> = v__917.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping450_hashtag__var_700: BitVector<5> = v__917.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping450_hashtag__var_700) && (encdec_freg_backwards_matches(mapping451_hashtag__var_699) && (encdec_rounding_mode_backwards_matches(mapping452_hashtag__var_698) && encdec_freg_backwards_matches(mapping453_hashtag__var_697)))) && ((v__917.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000010)) && (v__917.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping453_hashtag_: BitVector<5> = v__917.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping452_hashtag_: BitVector<3> = v__917.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping451_hashtag_: BitVector<5> = v__917.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping450_hashtag_: BitVector<5> = v__917.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping450_hashtag_), encdec_freg_backwards(mapping451_hashtag_), encdec_rounding_mode_backwards(mapping452_hashtag_), encdec_freg_backwards(mapping453_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FADD_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__914 if {let mapping457_hashtag__var_693: BitVector<5> = v__914.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping456_hashtag__var_694: BitVector<3> = v__914.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping455_hashtag__var_695: BitVector<5> = v__914.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping454_hashtag__var_696: BitVector<5> = v__914.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping454_hashtag__var_696) && (encdec_freg_backwards_matches(mapping455_hashtag__var_695) && (encdec_rounding_mode_backwards_matches(mapping456_hashtag__var_694) && encdec_freg_backwards_matches(mapping457_hashtag__var_693)))) && ((v__914.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000110)) && (v__914.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping457_hashtag_: BitVector<5> = v__914.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping456_hashtag_: BitVector<3> = v__914.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping455_hashtag_: BitVector<5> = v__914.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping454_hashtag_: BitVector<5> = v__914.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping454_hashtag_), encdec_freg_backwards(mapping455_hashtag_), encdec_rounding_mode_backwards(mapping456_hashtag_), encdec_freg_backwards(mapping457_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FSUB_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__911 if {let mapping461_hashtag__var_689: BitVector<5> = v__911.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping460_hashtag__var_690: BitVector<3> = v__911.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping459_hashtag__var_691: BitVector<5> = v__911.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping458_hashtag__var_692: BitVector<5> = v__911.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping458_hashtag__var_692) && (encdec_freg_backwards_matches(mapping459_hashtag__var_691) && (encdec_rounding_mode_backwards_matches(mapping460_hashtag__var_690) && encdec_freg_backwards_matches(mapping461_hashtag__var_689)))) && ((v__911.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001010)) && (v__911.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping461_hashtag_: BitVector<5> = v__911.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping460_hashtag_: BitVector<3> = v__911.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping459_hashtag_: BitVector<5> = v__911.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping458_hashtag_: BitVector<5> = v__911.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping458_hashtag_), encdec_freg_backwards(mapping459_hashtag_), encdec_rounding_mode_backwards(mapping460_hashtag_), encdec_freg_backwards(mapping461_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FMUL_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__908 if {let mapping465_hashtag__var_685: BitVector<5> = v__908.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping464_hashtag__var_686: BitVector<3> = v__908.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping463_hashtag__var_687: BitVector<5> = v__908.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping462_hashtag__var_688: BitVector<5> = v__908.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping462_hashtag__var_688) && (encdec_freg_backwards_matches(mapping463_hashtag__var_687) && (encdec_rounding_mode_backwards_matches(mapping464_hashtag__var_686) && encdec_freg_backwards_matches(mapping465_hashtag__var_685)))) && ((v__908.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0001110)) && (v__908.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping465_hashtag_: BitVector<5> = v__908.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping464_hashtag_: BitVector<3> = v__908.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping463_hashtag_: BitVector<5> = v__908.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping462_hashtag_: BitVector<5> = v__908.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping462_hashtag_), encdec_freg_backwards(mapping463_hashtag_), encdec_rounding_mode_backwards(mapping464_hashtag_), encdec_freg_backwards(mapping465_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, f_bin_rm_op_H::FDIV_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__905 if {let mapping466_hashtag__var_679: BitVector<5> = v__905.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping470_hashtag__var_680: BitVector<5> = v__905.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping469_hashtag__var_681: BitVector<3> = v__905.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping468_hashtag__var_682: BitVector<5> = v__905.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping467_hashtag__var_683: BitVector<5> = v__905.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping466_hashtag__var_684: BitVector<5> = v__905.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping466_hashtag__var_684) && (encdec_freg_backwards_matches(mapping467_hashtag__var_683) && (encdec_freg_backwards_matches(mapping468_hashtag__var_682) && (encdec_rounding_mode_backwards_matches(mapping469_hashtag__var_681) && encdec_freg_backwards_matches(mapping470_hashtag__var_680))))) && ((v__905.subrange::<25, 27, 2>() == BitVector::<2>::new(0b10)) && (v__905.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000011))))} => {let mapping466_hashtag_: BitVector<5> = v__905.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping470_hashtag_: BitVector<5> = v__905.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping469_hashtag_: BitVector<3> = v__905.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping468_hashtag_: BitVector<5> = v__905.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping467_hashtag_: BitVector<5> = v__905.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping466_hashtag_: BitVector<5> = v__905.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping466_hashtag_), encdec_freg_backwards(mapping467_hashtag_), encdec_freg_backwards(mapping468_hashtag_), encdec_rounding_mode_backwards(mapping469_hashtag_), encdec_freg_backwards(mapping470_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs3, rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FMADD_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__902 if {let mapping471_hashtag__var_673: BitVector<5> = v__902.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping475_hashtag__var_674: BitVector<5> = v__902.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping474_hashtag__var_675: BitVector<3> = v__902.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping473_hashtag__var_676: BitVector<5> = v__902.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping472_hashtag__var_677: BitVector<5> = v__902.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping471_hashtag__var_678: BitVector<5> = v__902.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping471_hashtag__var_678) && (encdec_freg_backwards_matches(mapping472_hashtag__var_677) && (encdec_freg_backwards_matches(mapping473_hashtag__var_676) && (encdec_rounding_mode_backwards_matches(mapping474_hashtag__var_675) && encdec_freg_backwards_matches(mapping475_hashtag__var_674))))) && ((v__902.subrange::<25, 27, 2>() == BitVector::<2>::new(0b10)) && (v__902.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1000111))))} => {let mapping471_hashtag_: BitVector<5> = v__902.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping475_hashtag_: BitVector<5> = v__902.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping474_hashtag_: BitVector<3> = v__902.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping473_hashtag_: BitVector<5> = v__902.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping472_hashtag_: BitVector<5> = v__902.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping471_hashtag_: BitVector<5> = v__902.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping471_hashtag_), encdec_freg_backwards(mapping472_hashtag_), encdec_freg_backwards(mapping473_hashtag_), encdec_rounding_mode_backwards(mapping474_hashtag_), encdec_freg_backwards(mapping475_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs3, rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FMSUB_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__899 if {let mapping476_hashtag__var_667: BitVector<5> = v__899.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping480_hashtag__var_668: BitVector<5> = v__899.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping479_hashtag__var_669: BitVector<3> = v__899.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping478_hashtag__var_670: BitVector<5> = v__899.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping477_hashtag__var_671: BitVector<5> = v__899.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping476_hashtag__var_672: BitVector<5> = v__899.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping476_hashtag__var_672) && (encdec_freg_backwards_matches(mapping477_hashtag__var_671) && (encdec_freg_backwards_matches(mapping478_hashtag__var_670) && (encdec_rounding_mode_backwards_matches(mapping479_hashtag__var_669) && encdec_freg_backwards_matches(mapping480_hashtag__var_668))))) && ((v__899.subrange::<25, 27, 2>() == BitVector::<2>::new(0b10)) && (v__899.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001011))))} => {let mapping476_hashtag_: BitVector<5> = v__899.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping480_hashtag_: BitVector<5> = v__899.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping479_hashtag_: BitVector<3> = v__899.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping478_hashtag_: BitVector<5> = v__899.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping477_hashtag_: BitVector<5> = v__899.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping476_hashtag_: BitVector<5> = v__899.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping476_hashtag_), encdec_freg_backwards(mapping477_hashtag_), encdec_freg_backwards(mapping478_hashtag_), encdec_rounding_mode_backwards(mapping479_hashtag_), encdec_freg_backwards(mapping480_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs3, rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FNMSUB_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__896 if {let mapping481_hashtag__var_661: BitVector<5> = v__896.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping485_hashtag__var_662: BitVector<5> = v__896.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping484_hashtag__var_663: BitVector<3> = v__896.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping483_hashtag__var_664: BitVector<5> = v__896.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping482_hashtag__var_665: BitVector<5> = v__896.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping481_hashtag__var_666: BitVector<5> = v__896.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping481_hashtag__var_666) && (encdec_freg_backwards_matches(mapping482_hashtag__var_665) && (encdec_freg_backwards_matches(mapping483_hashtag__var_664) && (encdec_rounding_mode_backwards_matches(mapping484_hashtag__var_663) && encdec_freg_backwards_matches(mapping485_hashtag__var_662))))) && ((v__896.subrange::<25, 27, 2>() == BitVector::<2>::new(0b10)) && (v__896.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1001111))))} => {let mapping481_hashtag_: BitVector<5> = v__896.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping485_hashtag_: BitVector<5> = v__896.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping484_hashtag_: BitVector<3> = v__896.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping483_hashtag_: BitVector<5> = v__896.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping482_hashtag_: BitVector<5> = v__896.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping481_hashtag_: BitVector<5> = v__896.subrange::<27, 32, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping481_hashtag_), encdec_freg_backwards(mapping482_hashtag_), encdec_freg_backwards(mapping483_hashtag_), encdec_rounding_mode_backwards(mapping484_hashtag_), encdec_freg_backwards(mapping485_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs3, rs2, rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, f_madd_op_H::FNMADD_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__892 if {let mapping488_hashtag__var_658: BitVector<5> = v__892.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping487_hashtag__var_659: BitVector<5> = v__892.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping486_hashtag__var_660: BitVector<5> = v__892.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping486_hashtag__var_660) && (encdec_freg_backwards_matches(mapping487_hashtag__var_659) && encdec_freg_backwards_matches(mapping488_hashtag__var_658))) && ((v__892.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010010)) && ((v__892.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__892.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping488_hashtag_: BitVector<5> = v__892.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping487_hashtag_: BitVector<5> = v__892.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping486_hashtag_: BitVector<5> = v__892.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping486_hashtag_), encdec_freg_backwards(mapping487_hashtag_), encdec_freg_backwards(mapping488_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJ_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__888 if {let mapping491_hashtag__var_655: BitVector<5> = v__888.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping490_hashtag__var_656: BitVector<5> = v__888.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping489_hashtag__var_657: BitVector<5> = v__888.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping489_hashtag__var_657) && (encdec_freg_backwards_matches(mapping490_hashtag__var_656) && encdec_freg_backwards_matches(mapping491_hashtag__var_655))) && ((v__888.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010010)) && ((v__888.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__888.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping491_hashtag_: BitVector<5> = v__888.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping490_hashtag_: BitVector<5> = v__888.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping489_hashtag_: BitVector<5> = v__888.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping489_hashtag_), encdec_freg_backwards(mapping490_hashtag_), encdec_freg_backwards(mapping491_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJN_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__884 if {let mapping494_hashtag__var_652: BitVector<5> = v__884.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping493_hashtag__var_653: BitVector<5> = v__884.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping492_hashtag__var_654: BitVector<5> = v__884.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping492_hashtag__var_654) && (encdec_freg_backwards_matches(mapping493_hashtag__var_653) && encdec_freg_backwards_matches(mapping494_hashtag__var_652))) && ((v__884.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010010)) && ((v__884.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__884.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping494_hashtag_: BitVector<5> = v__884.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping493_hashtag_: BitVector<5> = v__884.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping492_hashtag_: BitVector<5> = v__884.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping492_hashtag_), encdec_freg_backwards(mapping493_hashtag_), encdec_freg_backwards(mapping494_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJX_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__880 if {let mapping497_hashtag__var_649: BitVector<5> = v__880.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping496_hashtag__var_650: BitVector<5> = v__880.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping495_hashtag__var_651: BitVector<5> = v__880.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping495_hashtag__var_651) && (encdec_freg_backwards_matches(mapping496_hashtag__var_650) && encdec_freg_backwards_matches(mapping497_hashtag__var_649))) && ((v__880.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010110)) && ((v__880.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__880.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping497_hashtag_: BitVector<5> = v__880.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping496_hashtag_: BitVector<5> = v__880.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping495_hashtag_: BitVector<5> = v__880.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping495_hashtag_), encdec_freg_backwards(mapping496_hashtag_), encdec_freg_backwards(mapping497_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMIN_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__876 if {let mapping500_hashtag__var_646: BitVector<5> = v__876.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping499_hashtag__var_647: BitVector<5> = v__876.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping498_hashtag__var_648: BitVector<5> = v__876.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping498_hashtag__var_648) && (encdec_freg_backwards_matches(mapping499_hashtag__var_647) && encdec_freg_backwards_matches(mapping500_hashtag__var_646))) && ((v__876.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010110)) && ((v__876.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__876.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping500_hashtag_: BitVector<5> = v__876.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping499_hashtag_: BitVector<5> = v__876.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping498_hashtag_: BitVector<5> = v__876.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping498_hashtag_), encdec_freg_backwards(mapping499_hashtag_), encdec_freg_backwards(mapping500_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMAX_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__872 if {let mapping503_hashtag__var_643: BitVector<5> = v__872.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping502_hashtag__var_644: BitVector<5> = v__872.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping501_hashtag__var_645: BitVector<5> = v__872.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping501_hashtag__var_645) && (encdec_freg_backwards_matches(mapping502_hashtag__var_644) && encdec_reg_backwards_matches(mapping503_hashtag__var_643))) && ((v__872.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010010)) && ((v__872.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__872.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping503_hashtag_: BitVector<5> = v__872.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping502_hashtag_: BitVector<5> = v__872.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping501_hashtag_: BitVector<5> = v__872.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping501_hashtag_), encdec_freg_backwards(mapping502_hashtag_), encdec_reg_backwards(mapping503_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FEQ_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__868 if {let mapping506_hashtag__var_640: BitVector<5> = v__868.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping505_hashtag__var_641: BitVector<5> = v__868.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping504_hashtag__var_642: BitVector<5> = v__868.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping504_hashtag__var_642) && (encdec_freg_backwards_matches(mapping505_hashtag__var_641) && encdec_reg_backwards_matches(mapping506_hashtag__var_640))) && ((v__868.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010010)) && ((v__868.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__868.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping506_hashtag_: BitVector<5> = v__868.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping505_hashtag_: BitVector<5> = v__868.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping504_hashtag_: BitVector<5> = v__868.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping504_hashtag_), encdec_freg_backwards(mapping505_hashtag_), encdec_reg_backwards(mapping506_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLT_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__864 if {let mapping509_hashtag__var_637: BitVector<5> = v__864.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping508_hashtag__var_638: BitVector<5> = v__864.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping507_hashtag__var_639: BitVector<5> = v__864.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping507_hashtag__var_639) && (encdec_freg_backwards_matches(mapping508_hashtag__var_638) && encdec_reg_backwards_matches(mapping509_hashtag__var_637))) && ((v__864.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010010)) && ((v__864.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__864.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping509_hashtag_: BitVector<5> = v__864.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping508_hashtag_: BitVector<5> = v__864.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping507_hashtag_: BitVector<5> = v__864.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping507_hashtag_), encdec_freg_backwards(mapping508_hashtag_), encdec_reg_backwards(mapping509_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLE_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__860 if {let mapping512_hashtag__var_634: BitVector<5> = v__860.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping511_hashtag__var_635: BitVector<3> = v__860.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping510_hashtag__var_636: BitVector<5> = v__860.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping510_hashtag__var_636) && (encdec_rounding_mode_backwards_matches(mapping511_hashtag__var_635) && encdec_freg_backwards_matches(mapping512_hashtag__var_634))) && ((v__860.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010111000000)) && (v__860.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping512_hashtag_: BitVector<5> = v__860.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping511_hashtag_: BitVector<3> = v__860.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping510_hashtag_: BitVector<5> = v__860.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping510_hashtag_), encdec_rounding_mode_backwards(mapping511_hashtag_), encdec_freg_backwards(mapping512_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FSQRT_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__856 if {let mapping515_hashtag__var_631: BitVector<5> = v__856.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping514_hashtag__var_632: BitVector<3> = v__856.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping513_hashtag__var_633: BitVector<5> = v__856.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping513_hashtag__var_633) && (encdec_rounding_mode_backwards_matches(mapping514_hashtag__var_632) && encdec_reg_backwards_matches(mapping515_hashtag__var_631))) && ((v__856.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110001000000)) && (v__856.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping515_hashtag_: BitVector<5> = v__856.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping514_hashtag_: BitVector<3> = v__856.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping513_hashtag_: BitVector<5> = v__856.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping513_hashtag_), encdec_rounding_mode_backwards(mapping514_hashtag_), encdec_reg_backwards(mapping515_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_W_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__852 if {let mapping518_hashtag__var_628: BitVector<5> = v__852.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping517_hashtag__var_629: BitVector<3> = v__852.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping516_hashtag__var_630: BitVector<5> = v__852.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping516_hashtag__var_630) && (encdec_rounding_mode_backwards_matches(mapping517_hashtag__var_629) && encdec_reg_backwards_matches(mapping518_hashtag__var_628))) && ((v__852.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110001000001)) && (v__852.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping518_hashtag_: BitVector<5> = v__852.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping517_hashtag_: BitVector<3> = v__852.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping516_hashtag_: BitVector<5> = v__852.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping516_hashtag_), encdec_rounding_mode_backwards(mapping517_hashtag_), encdec_reg_backwards(mapping518_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_WU_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__848 if {let mapping521_hashtag__var_625: BitVector<5> = v__848.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping520_hashtag__var_626: BitVector<3> = v__848.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping519_hashtag__var_627: BitVector<5> = v__848.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping519_hashtag__var_627) && (encdec_rounding_mode_backwards_matches(mapping520_hashtag__var_626) && encdec_freg_backwards_matches(mapping521_hashtag__var_625))) && ((v__848.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110101000000)) && (v__848.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping521_hashtag_: BitVector<5> = v__848.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping520_hashtag_: BitVector<3> = v__848.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping519_hashtag_: BitVector<5> = v__848.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping519_hashtag_), encdec_rounding_mode_backwards(mapping520_hashtag_), encdec_freg_backwards(mapping521_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_W)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__844 if {let mapping524_hashtag__var_622: BitVector<5> = v__844.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping523_hashtag__var_623: BitVector<3> = v__844.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping522_hashtag__var_624: BitVector<5> = v__844.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping522_hashtag__var_624) && (encdec_rounding_mode_backwards_matches(mapping523_hashtag__var_623) && encdec_freg_backwards_matches(mapping524_hashtag__var_622))) && ((v__844.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110101000001)) && (v__844.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping524_hashtag_: BitVector<5> = v__844.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping523_hashtag_: BitVector<3> = v__844.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping522_hashtag_: BitVector<5> = v__844.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping522_hashtag_), encdec_rounding_mode_backwards(mapping523_hashtag_), encdec_freg_backwards(mapping524_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_WU)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__840 if {let mapping527_hashtag__var_619: BitVector<5> = v__840.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping526_hashtag__var_620: BitVector<3> = v__840.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping525_hashtag__var_621: BitVector<5> = v__840.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping525_hashtag__var_621) && (encdec_rounding_mode_backwards_matches(mapping526_hashtag__var_620) && encdec_freg_backwards_matches(mapping527_hashtag__var_619))) && ((v__840.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010001000000)) && (v__840.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping527_hashtag_: BitVector<5> = v__840.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping526_hashtag_: BitVector<3> = v__840.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping525_hashtag_: BitVector<5> = v__840.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping525_hashtag_), encdec_rounding_mode_backwards(mapping526_hashtag_), encdec_freg_backwards(mapping527_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveHalfMin(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_S)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__836 if {let mapping530_hashtag__var_616: BitVector<5> = v__836.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping529_hashtag__var_617: BitVector<3> = v__836.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping528_hashtag__var_618: BitVector<5> = v__836.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping528_hashtag__var_618) && (encdec_rounding_mode_backwards_matches(mapping529_hashtag__var_617) && encdec_freg_backwards_matches(mapping530_hashtag__var_616))) && ((v__836.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010001000001)) && (v__836.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping530_hashtag_: BitVector<5> = v__836.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping529_hashtag_: BitVector<3> = v__836.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping528_hashtag_: BitVector<5> = v__836.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping528_hashtag_), encdec_rounding_mode_backwards(mapping529_hashtag_), encdec_freg_backwards(mapping530_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {(haveHalfMin(core_ctx, ()) && haveDoubleFPU(core_ctx, ()))} => {Some(ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_D)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__832 if {let mapping533_hashtag__var_613: BitVector<5> = v__832.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping532_hashtag__var_614: BitVector<3> = v__832.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping531_hashtag__var_615: BitVector<5> = v__832.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping531_hashtag__var_615) && (encdec_rounding_mode_backwards_matches(mapping532_hashtag__var_614) && encdec_freg_backwards_matches(mapping533_hashtag__var_613))) && ((v__832.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000000010)) && (v__832.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping533_hashtag_: BitVector<5> = v__832.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping532_hashtag_: BitVector<3> = v__832.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping531_hashtag_: BitVector<5> = v__832.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping531_hashtag_), encdec_rounding_mode_backwards(mapping532_hashtag_), encdec_freg_backwards(mapping533_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveHalfMin(core_ctx, ())} => {Some(ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_S_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__828 if {let mapping536_hashtag__var_610: BitVector<5> = v__828.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping535_hashtag__var_611: BitVector<3> = v__828.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping534_hashtag__var_612: BitVector<5> = v__828.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping534_hashtag__var_612) && (encdec_rounding_mode_backwards_matches(mapping535_hashtag__var_611) && encdec_freg_backwards_matches(mapping536_hashtag__var_610))) && ((v__828.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100010)) && (v__828.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping536_hashtag_: BitVector<5> = v__828.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping535_hashtag_: BitVector<3> = v__828.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping534_hashtag_: BitVector<5> = v__828.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping534_hashtag_), encdec_rounding_mode_backwards(mapping535_hashtag_), encdec_freg_backwards(mapping536_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {(haveHalfMin(core_ctx, ()) && haveDoubleFPU(core_ctx, ()))} => {Some(ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_D_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__824 if {let mapping539_hashtag__var_607: BitVector<5> = v__824.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping538_hashtag__var_608: BitVector<3> = v__824.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping537_hashtag__var_609: BitVector<5> = v__824.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping537_hashtag__var_609) && (encdec_rounding_mode_backwards_matches(mapping538_hashtag__var_608) && encdec_reg_backwards_matches(mapping539_hashtag__var_607))) && ((v__824.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110001000010)) && (v__824.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping539_hashtag_: BitVector<5> = v__824.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping538_hashtag_: BitVector<3> = v__824.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping537_hashtag_: BitVector<5> = v__824.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping537_hashtag_), encdec_rounding_mode_backwards(mapping538_hashtag_), encdec_reg_backwards(mapping539_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_L_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__820 if {let mapping542_hashtag__var_604: BitVector<5> = v__820.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping541_hashtag__var_605: BitVector<3> = v__820.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping540_hashtag__var_606: BitVector<5> = v__820.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping540_hashtag__var_606) && (encdec_rounding_mode_backwards_matches(mapping541_hashtag__var_605) && encdec_reg_backwards_matches(mapping542_hashtag__var_604))) && ((v__820.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110001000011)) && (v__820.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping542_hashtag_: BitVector<5> = v__820.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping541_hashtag_: BitVector<3> = v__820.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping540_hashtag_: BitVector<5> = v__820.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping540_hashtag_), encdec_rounding_mode_backwards(mapping541_hashtag_), encdec_reg_backwards(mapping542_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_LU_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__816 if {let mapping545_hashtag__var_601: BitVector<5> = v__816.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping544_hashtag__var_602: BitVector<3> = v__816.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping543_hashtag__var_603: BitVector<5> = v__816.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping543_hashtag__var_603) && (encdec_rounding_mode_backwards_matches(mapping544_hashtag__var_602) && encdec_freg_backwards_matches(mapping545_hashtag__var_601))) && ((v__816.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110101000010)) && (v__816.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping545_hashtag_: BitVector<5> = v__816.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping544_hashtag_: BitVector<3> = v__816.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping543_hashtag_: BitVector<5> = v__816.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping543_hashtag_), encdec_rounding_mode_backwards(mapping544_hashtag_), encdec_freg_backwards(mapping545_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_L)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__812 if {let mapping548_hashtag__var_598: BitVector<5> = v__812.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping547_hashtag__var_599: BitVector<3> = v__812.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping546_hashtag__var_600: BitVector<5> = v__812.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping546_hashtag__var_600) && (encdec_rounding_mode_backwards_matches(mapping547_hashtag__var_599) && encdec_freg_backwards_matches(mapping548_hashtag__var_598))) && ((v__812.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110101000011)) && (v__812.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping548_hashtag_: BitVector<5> = v__812.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping547_hashtag_: BitVector<3> = v__812.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping546_hashtag_: BitVector<5> = v__812.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping546_hashtag_), encdec_rounding_mode_backwards(mapping547_hashtag_), encdec_freg_backwards(mapping548_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_LU)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__807 if {let mapping550_hashtag__var_596: BitVector<5> = v__807.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping549_hashtag__var_597: BitVector<5> = v__807.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping549_hashtag__var_597) && encdec_reg_backwards_matches(mapping550_hashtag__var_596)) && ((v__807.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111001000000)) && ((v__807.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__807.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping550_hashtag_: BitVector<5> = v__807.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping549_hashtag_: BitVector<5> = v__807.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping549_hashtag_), encdec_reg_backwards(mapping550_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {haveHalfFPU(core_ctx, ())} => {Some(ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FCLASS_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__802 if {let mapping552_hashtag__var_594: BitVector<5> = v__802.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping551_hashtag__var_595: BitVector<5> = v__802.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping551_hashtag__var_595) && encdec_reg_backwards_matches(mapping552_hashtag__var_594)) && ((v__802.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111001000000)) && ((v__802.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__802.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping552_hashtag_: BitVector<5> = v__802.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping551_hashtag_: BitVector<5> = v__802.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping551_hashtag_), encdec_reg_backwards(mapping552_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {Some(ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FMV_X_H)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__797 if {let mapping554_hashtag__var_592: BitVector<5> = v__797.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping553_hashtag__var_593: BitVector<5> = v__797.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping553_hashtag__var_593) && encdec_freg_backwards_matches(mapping554_hashtag__var_592)) && ((v__797.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111101000000)) && ((v__797.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__797.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping554_hashtag_: BitVector<5> = v__797.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping553_hashtag_: BitVector<5> = v__797.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping553_hashtag_), encdec_freg_backwards(mapping554_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfhmin)} => {Some(ast::F_UN_F_TYPE_H((rs1, rd, f_un_f_op_H::FMV_H_X)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__792 if {let mapping555_hashtag__var_591: BitVector<5> = v__792.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (encdec_freg_backwards_matches(mapping555_hashtag__var_591) && ((v__792.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111101000001)) && ((v__792.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__792.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping555_hashtag_: BitVector<5> = v__792.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let constantidx: BitVector<5> = v__792.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match encdec_freg_backwards(mapping555_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rd if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLI_H((constantidx, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__787 if {let mapping556_hashtag__var_590: BitVector<5> = v__787.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (encdec_freg_backwards_matches(mapping556_hashtag__var_590) && ((v__787.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111100000001)) && ((v__787.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__787.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping556_hashtag_: BitVector<5> = v__787.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let constantidx: BitVector<5> = v__787.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match encdec_freg_backwards(mapping556_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rd if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FLI_S((constantidx, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__782 if {let mapping557_hashtag__var_589: BitVector<5> = v__782.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (encdec_freg_backwards_matches(mapping557_hashtag__var_589) && ((v__782.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111100100001)) && ((v__782.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__782.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping557_hashtag_: BitVector<5> = v__782.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let constantidx: BitVector<5> = v__782.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match encdec_freg_backwards(mapping557_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rd if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLI_D((constantidx, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__778 if {let mapping560_hashtag__var_586: BitVector<5> = v__778.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping559_hashtag__var_587: BitVector<5> = v__778.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping558_hashtag__var_588: BitVector<5> = v__778.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping558_hashtag__var_588) && (encdec_freg_backwards_matches(mapping559_hashtag__var_587) && encdec_freg_backwards_matches(mapping560_hashtag__var_586))) && ((v__778.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010110)) && ((v__778.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__778.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping560_hashtag_: BitVector<5> = v__778.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping559_hashtag_: BitVector<5> = v__778.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping558_hashtag_: BitVector<5> = v__778.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping558_hashtag_), encdec_freg_backwards(mapping559_hashtag_), encdec_freg_backwards(mapping560_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FMINM_H((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__774 if {let mapping563_hashtag__var_583: BitVector<5> = v__774.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping562_hashtag__var_584: BitVector<5> = v__774.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping561_hashtag__var_585: BitVector<5> = v__774.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping561_hashtag__var_585) && (encdec_freg_backwards_matches(mapping562_hashtag__var_584) && encdec_freg_backwards_matches(mapping563_hashtag__var_583))) && ((v__774.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010110)) && ((v__774.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__774.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping563_hashtag_: BitVector<5> = v__774.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping562_hashtag_: BitVector<5> = v__774.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping561_hashtag_: BitVector<5> = v__774.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping561_hashtag_), encdec_freg_backwards(mapping562_hashtag_), encdec_freg_backwards(mapping563_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FMAXM_H((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__770 if {let mapping566_hashtag__var_580: BitVector<5> = v__770.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping565_hashtag__var_581: BitVector<5> = v__770.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping564_hashtag__var_582: BitVector<5> = v__770.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping564_hashtag__var_582) && (encdec_freg_backwards_matches(mapping565_hashtag__var_581) && encdec_freg_backwards_matches(mapping566_hashtag__var_580))) && ((v__770.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__770.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__770.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping566_hashtag_: BitVector<5> = v__770.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping565_hashtag_: BitVector<5> = v__770.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping564_hashtag_: BitVector<5> = v__770.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping564_hashtag_), encdec_freg_backwards(mapping565_hashtag_), encdec_freg_backwards(mapping566_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FMINM_S((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__766 if {let mapping569_hashtag__var_577: BitVector<5> = v__766.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping568_hashtag__var_578: BitVector<5> = v__766.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping567_hashtag__var_579: BitVector<5> = v__766.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping567_hashtag__var_579) && (encdec_freg_backwards_matches(mapping568_hashtag__var_578) && encdec_freg_backwards_matches(mapping569_hashtag__var_577))) && ((v__766.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__766.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__766.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping569_hashtag_: BitVector<5> = v__766.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping568_hashtag_: BitVector<5> = v__766.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping567_hashtag_: BitVector<5> = v__766.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping567_hashtag_), encdec_freg_backwards(mapping568_hashtag_), encdec_freg_backwards(mapping569_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FMAXM_S((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__762 if {let mapping572_hashtag__var_574: BitVector<5> = v__762.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping571_hashtag__var_575: BitVector<5> = v__762.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping570_hashtag__var_576: BitVector<5> = v__762.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping570_hashtag__var_576) && (encdec_freg_backwards_matches(mapping571_hashtag__var_575) && encdec_freg_backwards_matches(mapping572_hashtag__var_574))) && ((v__762.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010101)) && ((v__762.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__762.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping572_hashtag_: BitVector<5> = v__762.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping571_hashtag_: BitVector<5> = v__762.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping570_hashtag_: BitVector<5> = v__762.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping570_hashtag_), encdec_freg_backwards(mapping571_hashtag_), encdec_freg_backwards(mapping572_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FMINM_D((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__758 if {let mapping575_hashtag__var_571: BitVector<5> = v__758.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping574_hashtag__var_572: BitVector<5> = v__758.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping573_hashtag__var_573: BitVector<5> = v__758.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping573_hashtag__var_573) && (encdec_freg_backwards_matches(mapping574_hashtag__var_572) && encdec_freg_backwards_matches(mapping575_hashtag__var_571))) && ((v__758.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010101)) && ((v__758.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__758.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping575_hashtag_: BitVector<5> = v__758.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping574_hashtag_: BitVector<5> = v__758.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping573_hashtag_: BitVector<5> = v__758.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping573_hashtag_), encdec_freg_backwards(mapping574_hashtag_), encdec_freg_backwards(mapping575_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FMAXM_D((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__754 if {let mapping578_hashtag__var_568: BitVector<5> = v__754.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping577_hashtag__var_569: BitVector<3> = v__754.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping576_hashtag__var_570: BitVector<5> = v__754.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping576_hashtag__var_570) && (encdec_rounding_mode_backwards_matches(mapping577_hashtag__var_569) && encdec_freg_backwards_matches(mapping578_hashtag__var_568))) && ((v__754.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010001000100)) && (v__754.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping578_hashtag_: BitVector<5> = v__754.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping577_hashtag_: BitVector<3> = v__754.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping576_hashtag_: BitVector<5> = v__754.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping576_hashtag_), encdec_rounding_mode_backwards(mapping577_hashtag_), encdec_freg_backwards(mapping578_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FROUND_H((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__750 if {let mapping581_hashtag__var_565: BitVector<5> = v__750.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping580_hashtag__var_566: BitVector<3> = v__750.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping579_hashtag__var_567: BitVector<5> = v__750.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping579_hashtag__var_567) && (encdec_rounding_mode_backwards_matches(mapping580_hashtag__var_566) && encdec_freg_backwards_matches(mapping581_hashtag__var_565))) && ((v__750.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010001000101)) && (v__750.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping581_hashtag_: BitVector<5> = v__750.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping580_hashtag_: BitVector<3> = v__750.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping579_hashtag_: BitVector<5> = v__750.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping579_hashtag_), encdec_rounding_mode_backwards(mapping580_hashtag_), encdec_freg_backwards(mapping581_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FROUNDNX_H((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__746 if {let mapping584_hashtag__var_562: BitVector<5> = v__746.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping583_hashtag__var_563: BitVector<3> = v__746.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping582_hashtag__var_564: BitVector<5> = v__746.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping582_hashtag__var_564) && (encdec_rounding_mode_backwards_matches(mapping583_hashtag__var_563) && encdec_freg_backwards_matches(mapping584_hashtag__var_562))) && ((v__746.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000000100)) && (v__746.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping584_hashtag_: BitVector<5> = v__746.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping583_hashtag_: BitVector<3> = v__746.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping582_hashtag_: BitVector<5> = v__746.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping582_hashtag_), encdec_rounding_mode_backwards(mapping583_hashtag_), encdec_freg_backwards(mapping584_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rm, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FROUND_S((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__742 if {let mapping587_hashtag__var_559: BitVector<5> = v__742.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping586_hashtag__var_560: BitVector<3> = v__742.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping585_hashtag__var_561: BitVector<5> = v__742.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping585_hashtag__var_561) && (encdec_rounding_mode_backwards_matches(mapping586_hashtag__var_560) && encdec_freg_backwards_matches(mapping587_hashtag__var_559))) && ((v__742.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000000101)) && (v__742.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping587_hashtag_: BitVector<5> = v__742.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping586_hashtag_: BitVector<3> = v__742.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping585_hashtag_: BitVector<5> = v__742.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping585_hashtag_), encdec_rounding_mode_backwards(mapping586_hashtag_), encdec_freg_backwards(mapping587_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rm, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FROUNDNX_S((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__738 if {let mapping590_hashtag__var_556: BitVector<5> = v__738.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping589_hashtag__var_557: BitVector<3> = v__738.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping588_hashtag__var_558: BitVector<5> = v__738.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping588_hashtag__var_558) && (encdec_rounding_mode_backwards_matches(mapping589_hashtag__var_557) && encdec_freg_backwards_matches(mapping590_hashtag__var_556))) && ((v__738.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100100)) && (v__738.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping590_hashtag_: BitVector<5> = v__738.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping589_hashtag_: BitVector<3> = v__738.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping588_hashtag_: BitVector<5> = v__738.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping588_hashtag_), encdec_rounding_mode_backwards(mapping589_hashtag_), encdec_freg_backwards(mapping590_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rm, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FROUND_D((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__734 if {let mapping593_hashtag__var_553: BitVector<5> = v__734.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping592_hashtag__var_554: BitVector<3> = v__734.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping591_hashtag__var_555: BitVector<5> = v__734.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping591_hashtag__var_555) && (encdec_rounding_mode_backwards_matches(mapping592_hashtag__var_554) && encdec_freg_backwards_matches(mapping593_hashtag__var_553))) && ((v__734.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100101)) && (v__734.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011))))} => {let mapping593_hashtag_: BitVector<5> = v__734.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping592_hashtag_: BitVector<3> = v__734.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping591_hashtag_: BitVector<5> = v__734.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping591_hashtag_), encdec_rounding_mode_backwards(mapping592_hashtag_), encdec_freg_backwards(mapping593_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rm, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FROUNDNX_D((rs1, rm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__729 if {let mapping595_hashtag__var_551: BitVector<5> = v__729.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping594_hashtag__var_552: BitVector<5> = v__729.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping594_hashtag__var_552) && encdec_reg_backwards_matches(mapping595_hashtag__var_551)) && ((v__729.subrange::<20, 32, 12>() == BitVector::<12>::new(0b111000100001)) && ((v__729.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__729.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping595_hashtag_: BitVector<5> = v__729.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping594_hashtag_: BitVector<5> = v__729.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping594_hashtag_), encdec_reg_backwards(mapping595_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && (currentlyEnabled(core_ctx, extension::Ext_Zfa) && in32BitMode(core_ctx, ())))} => {Some(ast::FMVH_X_D((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__725 if {let mapping598_hashtag__var_548: BitVector<5> = v__725.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping597_hashtag__var_549: BitVector<5> = v__725.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping596_hashtag__var_550: BitVector<5> = v__725.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping596_hashtag__var_550) && (encdec_reg_backwards_matches(mapping597_hashtag__var_549) && encdec_freg_backwards_matches(mapping598_hashtag__var_548))) && ((v__725.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1011001)) && ((v__725.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__725.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping598_hashtag_: BitVector<5> = v__725.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping597_hashtag_: BitVector<5> = v__725.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping596_hashtag_: BitVector<5> = v__725.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping596_hashtag_), encdec_reg_backwards(mapping597_hashtag_), encdec_freg_backwards(mapping598_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && (currentlyEnabled(core_ctx, extension::Ext_Zfa) && in32BitMode(core_ctx, ())))} => {Some(ast::FMVP_D_X((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__721 if {let mapping601_hashtag__var_545: BitVector<5> = v__721.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping600_hashtag__var_546: BitVector<5> = v__721.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping599_hashtag__var_547: BitVector<5> = v__721.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping599_hashtag__var_547) && (encdec_freg_backwards_matches(mapping600_hashtag__var_546) && encdec_reg_backwards_matches(mapping601_hashtag__var_545))) && ((v__721.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010010)) && ((v__721.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__721.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping601_hashtag_: BitVector<5> = v__721.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping600_hashtag_: BitVector<5> = v__721.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping599_hashtag_: BitVector<5> = v__721.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping599_hashtag_), encdec_freg_backwards(mapping600_hashtag_), encdec_reg_backwards(mapping601_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLEQ_H((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__717 if {let mapping604_hashtag__var_542: BitVector<5> = v__717.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping603_hashtag__var_543: BitVector<5> = v__717.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping602_hashtag__var_544: BitVector<5> = v__717.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping602_hashtag__var_544) && (encdec_freg_backwards_matches(mapping603_hashtag__var_543) && encdec_reg_backwards_matches(mapping604_hashtag__var_542))) && ((v__717.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010010)) && ((v__717.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__717.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping604_hashtag_: BitVector<5> = v__717.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping603_hashtag_: BitVector<5> = v__717.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping602_hashtag_: BitVector<5> = v__717.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping602_hashtag_), encdec_freg_backwards(mapping603_hashtag_), encdec_reg_backwards(mapping604_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zfh) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLTQ_H((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__713 if {let mapping607_hashtag__var_539: BitVector<5> = v__713.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping606_hashtag__var_540: BitVector<5> = v__713.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping605_hashtag__var_541: BitVector<5> = v__713.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping605_hashtag__var_541) && (encdec_freg_backwards_matches(mapping606_hashtag__var_540) && encdec_reg_backwards_matches(mapping607_hashtag__var_539))) && ((v__713.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010000)) && ((v__713.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__713.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping607_hashtag_: BitVector<5> = v__713.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping606_hashtag_: BitVector<5> = v__713.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping605_hashtag_: BitVector<5> = v__713.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping605_hashtag_), encdec_freg_backwards(mapping606_hashtag_), encdec_reg_backwards(mapping607_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FLEQ_S((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__709 if {let mapping610_hashtag__var_536: BitVector<5> = v__709.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping609_hashtag__var_537: BitVector<5> = v__709.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping608_hashtag__var_538: BitVector<5> = v__709.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping608_hashtag__var_538) && (encdec_freg_backwards_matches(mapping609_hashtag__var_537) && encdec_reg_backwards_matches(mapping610_hashtag__var_536))) && ((v__709.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010000)) && ((v__709.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__709.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping610_hashtag_: BitVector<5> = v__709.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping609_hashtag_: BitVector<5> = v__709.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping608_hashtag_: BitVector<5> = v__709.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping608_hashtag_), encdec_freg_backwards(mapping609_hashtag_), encdec_reg_backwards(mapping610_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zfa)} => {Some(ast::FLTQ_S((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__705 if {let mapping613_hashtag__var_533: BitVector<5> = v__705.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping612_hashtag__var_534: BitVector<5> = v__705.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping611_hashtag__var_535: BitVector<5> = v__705.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping611_hashtag__var_535) && (encdec_freg_backwards_matches(mapping612_hashtag__var_534) && encdec_reg_backwards_matches(mapping613_hashtag__var_533))) && ((v__705.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010001)) && ((v__705.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__705.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping613_hashtag_: BitVector<5> = v__705.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping612_hashtag_: BitVector<5> = v__705.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping611_hashtag_: BitVector<5> = v__705.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping611_hashtag_), encdec_freg_backwards(mapping612_hashtag_), encdec_reg_backwards(mapping613_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLEQ_D((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__701 if {let mapping616_hashtag__var_530: BitVector<5> = v__701.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping615_hashtag__var_531: BitVector<5> = v__701.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping614_hashtag__var_532: BitVector<5> = v__701.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_freg_backwards_matches(mapping614_hashtag__var_532) && (encdec_freg_backwards_matches(mapping615_hashtag__var_531) && encdec_reg_backwards_matches(mapping616_hashtag__var_530))) && ((v__701.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010001)) && ((v__701.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__701.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping616_hashtag_: BitVector<5> = v__701.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping615_hashtag_: BitVector<5> = v__701.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping614_hashtag_: BitVector<5> = v__701.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_freg_backwards(mapping614_hashtag_), encdec_freg_backwards(mapping615_hashtag_), encdec_reg_backwards(mapping616_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FLTQ_D((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__696 if {let mapping618_hashtag__var_528: BitVector<5> = v__696.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping617_hashtag__var_529: BitVector<5> = v__696.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_freg_backwards_matches(mapping617_hashtag__var_529) && encdec_reg_backwards_matches(mapping618_hashtag__var_528)) && ((v__696.subrange::<20, 32, 12>() == BitVector::<12>::new(0b110000101000)) && ((v__696.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__696.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010011)))))} => {let mapping618_hashtag_: BitVector<5> = v__696.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping617_hashtag_: BitVector<5> = v__696.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_freg_backwards(mapping617_hashtag_), encdec_reg_backwards(mapping618_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_D) && currentlyEnabled(core_ctx, extension::Ext_Zfa))} => {Some(ast::FCVTMOD_W_D((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__690 if {let mapping620_hashtag__var_526: BitVector<5> = v__690.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping619_hashtag__var_527: BitVector<5> = v__690.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping619_hashtag__var_527) && encdec_reg_backwards_matches(mapping620_hashtag__var_526)) && ((v__690.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000000)) && ((v__690.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__690.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping620_hashtag_: BitVector<5> = v__690.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping619_hashtag_: BitVector<5> = v__690.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping619_hashtag_), encdec_reg_backwards(mapping620_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA256SUM0((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__684 if {let mapping622_hashtag__var_524: BitVector<5> = v__684.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping621_hashtag__var_525: BitVector<5> = v__684.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping621_hashtag__var_525) && encdec_reg_backwards_matches(mapping622_hashtag__var_524)) && ((v__684.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000001)) && ((v__684.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__684.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping622_hashtag_: BitVector<5> = v__684.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping621_hashtag_: BitVector<5> = v__684.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping621_hashtag_), encdec_reg_backwards(mapping622_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA256SUM1((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__678 if {let mapping624_hashtag__var_522: BitVector<5> = v__678.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping623_hashtag__var_523: BitVector<5> = v__678.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping623_hashtag__var_523) && encdec_reg_backwards_matches(mapping624_hashtag__var_522)) && ((v__678.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000010)) && ((v__678.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__678.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping624_hashtag_: BitVector<5> = v__678.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping623_hashtag_: BitVector<5> = v__678.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping623_hashtag_), encdec_reg_backwards(mapping624_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA256SIG0((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__672 if {let mapping626_hashtag__var_520: BitVector<5> = v__672.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping625_hashtag__var_521: BitVector<5> = v__672.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping625_hashtag__var_521) && encdec_reg_backwards_matches(mapping626_hashtag__var_520)) && ((v__672.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000011)) && ((v__672.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__672.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping626_hashtag_: BitVector<5> = v__672.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping625_hashtag_: BitVector<5> = v__672.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping625_hashtag_), encdec_reg_backwards(mapping626_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA256SIG1((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__668 if {let mapping629_hashtag__var_517: BitVector<5> = v__668.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping628_hashtag__var_518: BitVector<5> = v__668.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping627_hashtag__var_519: BitVector<5> = v__668.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping627_hashtag__var_519) && (encdec_reg_backwards_matches(mapping628_hashtag__var_518) && encdec_reg_backwards_matches(mapping629_hashtag__var_517))) && ((v__668.subrange::<25, 30, 5>() == BitVector::<5>::new(0b10011)) && ((v__668.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__668.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__668.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping629_hashtag_: BitVector<5> = v__668.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping628_hashtag_: BitVector<5> = v__668.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping627_hashtag_: BitVector<5> = v__668.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let bs: BitVector<2> = v__668.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__664 if {let mapping632_hashtag__var_514: BitVector<5> = v__664.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping631_hashtag__var_515: BitVector<5> = v__664.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping630_hashtag__var_516: BitVector<5> = v__664.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping630_hashtag__var_516) && (encdec_reg_backwards_matches(mapping631_hashtag__var_515) && encdec_reg_backwards_matches(mapping632_hashtag__var_514))) && ((v__664.subrange::<25, 30, 5>() == BitVector::<5>::new(0b10001)) && ((v__664.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__664.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__664.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping632_hashtag_: BitVector<5> = v__664.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping631_hashtag_: BitVector<5> = v__664.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping630_hashtag_: BitVector<5> = v__664.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let bs: BitVector<2> = v__664.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__660 if {let mapping635_hashtag__var_511: BitVector<5> = v__660.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping634_hashtag__var_512: BitVector<5> = v__660.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping633_hashtag__var_513: BitVector<5> = v__660.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping633_hashtag__var_513) && (encdec_reg_backwards_matches(mapping634_hashtag__var_512) && encdec_reg_backwards_matches(mapping635_hashtag__var_511))) && ((v__660.subrange::<25, 30, 5>() == BitVector::<5>::new(0b10111)) && ((v__660.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__660.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__660.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping635_hashtag_: BitVector<5> = v__660.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping634_hashtag_: BitVector<5> = v__660.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping633_hashtag_: BitVector<5> = v__660.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let bs: BitVector<2> = v__660.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__656 if {let mapping638_hashtag__var_508: BitVector<5> = v__656.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping637_hashtag__var_509: BitVector<5> = v__656.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping636_hashtag__var_510: BitVector<5> = v__656.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping636_hashtag__var_510) && (encdec_reg_backwards_matches(mapping637_hashtag__var_509) && encdec_reg_backwards_matches(mapping638_hashtag__var_508))) && ((v__656.subrange::<25, 30, 5>() == BitVector::<5>::new(0b10101)) && ((v__656.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__656.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__656.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping638_hashtag_: BitVector<5> = v__656.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping637_hashtag_: BitVector<5> = v__656.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping636_hashtag_: BitVector<5> = v__656.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let bs: BitVector<2> = v__656.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__651 if {let mapping641_hashtag__var_505: BitVector<5> = v__651.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping640_hashtag__var_506: BitVector<5> = v__651.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping639_hashtag__var_507: BitVector<5> = v__651.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping639_hashtag__var_507) && (encdec_reg_backwards_matches(mapping640_hashtag__var_506) && encdec_reg_backwards_matches(mapping641_hashtag__var_505))) && ((v__651.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101000)) && ((v__651.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__651.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping641_hashtag_: BitVector<5> = v__651.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping640_hashtag_: BitVector<5> = v__651.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping639_hashtag_: BitVector<5> = v__651.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__646 if {let mapping644_hashtag__var_502: BitVector<5> = v__646.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping643_hashtag__var_503: BitVector<5> = v__646.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping642_hashtag__var_504: BitVector<5> = v__646.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping642_hashtag__var_504) && (encdec_reg_backwards_matches(mapping643_hashtag__var_503) && encdec_reg_backwards_matches(mapping644_hashtag__var_502))) && ((v__646.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101001)) && ((v__646.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__646.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping644_hashtag_: BitVector<5> = v__646.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping643_hashtag_: BitVector<5> = v__646.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping642_hashtag_: BitVector<5> = v__646.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__641 if {let mapping647_hashtag__var_499: BitVector<5> = v__641.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping646_hashtag__var_500: BitVector<5> = v__641.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping645_hashtag__var_501: BitVector<5> = v__641.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping645_hashtag__var_501) && (encdec_reg_backwards_matches(mapping646_hashtag__var_500) && encdec_reg_backwards_matches(mapping647_hashtag__var_499))) && ((v__641.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101010)) && ((v__641.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__641.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping647_hashtag_: BitVector<5> = v__641.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping646_hashtag_: BitVector<5> = v__641.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping645_hashtag_: BitVector<5> = v__641.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__636 if {let mapping650_hashtag__var_496: BitVector<5> = v__636.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping649_hashtag__var_497: BitVector<5> = v__636.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping648_hashtag__var_498: BitVector<5> = v__636.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping648_hashtag__var_498) && (encdec_reg_backwards_matches(mapping649_hashtag__var_497) && encdec_reg_backwards_matches(mapping650_hashtag__var_496))) && ((v__636.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101110)) && ((v__636.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__636.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping650_hashtag_: BitVector<5> = v__636.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping649_hashtag_: BitVector<5> = v__636.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping648_hashtag_: BitVector<5> = v__636.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__631 if {let mapping653_hashtag__var_493: BitVector<5> = v__631.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping652_hashtag__var_494: BitVector<5> = v__631.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping651_hashtag__var_495: BitVector<5> = v__631.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping651_hashtag__var_495) && (encdec_reg_backwards_matches(mapping652_hashtag__var_494) && encdec_reg_backwards_matches(mapping653_hashtag__var_493))) && ((v__631.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101011)) && ((v__631.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__631.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping653_hashtag_: BitVector<5> = v__631.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping652_hashtag_: BitVector<5> = v__631.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping651_hashtag_: BitVector<5> = v__631.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__626 if {let mapping656_hashtag__var_490: BitVector<5> = v__626.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping655_hashtag__var_491: BitVector<5> = v__626.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping654_hashtag__var_492: BitVector<5> = v__626.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping654_hashtag__var_492) && (encdec_reg_backwards_matches(mapping655_hashtag__var_491) && encdec_reg_backwards_matches(mapping656_hashtag__var_490))) && ((v__626.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101111)) && ((v__626.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__626.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping656_hashtag_: BitVector<5> = v__626.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping655_hashtag_: BitVector<5> = v__626.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping654_hashtag_: BitVector<5> = v__626.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__620 if {let mapping658_hashtag__var_488: BitVector<5> = v__620.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping657_hashtag__var_489: BitVector<5> = v__620.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping657_hashtag__var_489) && encdec_reg_backwards_matches(mapping658_hashtag__var_488)) && ((v__620.subrange::<24, 32, 8>() == BitVector::<8>::new(0b00110001)) && ((v__620.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__620.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let rnum: BitVector<4> = v__620.subrange::<20, 24, 4>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping658_hashtag_: BitVector<5> = v__620.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping657_hashtag_: BitVector<5> = v__620.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping657_hashtag_), encdec_reg_backwards(mapping658_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {((currentlyEnabled(core_ctx, extension::Ext_Zkne) || currentlyEnabled(core_ctx, extension::Ext_Zknd)) && _operator_smaller_u_(rnum, BitVector::<4>::new(0b1011)))} => {Some(ast::AES64KS1I((rnum, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__614 if {let mapping660_hashtag__var_486: BitVector<5> = v__614.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping659_hashtag__var_487: BitVector<5> = v__614.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping659_hashtag__var_487) && encdec_reg_backwards_matches(mapping660_hashtag__var_486)) && ((v__614.subrange::<20, 32, 12>() == BitVector::<12>::new(0b001100000000)) && ((v__614.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__614.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping660_hashtag_: BitVector<5> = v__614.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping659_hashtag_: BitVector<5> = v__614.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping659_hashtag_), encdec_reg_backwards(mapping660_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {Some(ast::AES64IM((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__609 if {let mapping663_hashtag__var_483: BitVector<5> = v__609.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping662_hashtag__var_484: BitVector<5> = v__609.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping661_hashtag__var_485: BitVector<5> = v__609.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping661_hashtag__var_485) && (encdec_reg_backwards_matches(mapping662_hashtag__var_484) && encdec_reg_backwards_matches(mapping663_hashtag__var_483))) && ((v__609.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0111111)) && ((v__609.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__609.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping663_hashtag_: BitVector<5> = v__609.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping662_hashtag_: BitVector<5> = v__609.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping661_hashtag_: BitVector<5> = v__609.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping661_hashtag_), encdec_reg_backwards(mapping662_hashtag_), encdec_reg_backwards(mapping663_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {(currentlyEnabled(core_ctx, extension::Ext_Zkne) || currentlyEnabled(core_ctx, extension::Ext_Zknd))} => {Some(ast::AES64KS2((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__604 if {let mapping666_hashtag__var_480: BitVector<5> = v__604.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping665_hashtag__var_481: BitVector<5> = v__604.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping664_hashtag__var_482: BitVector<5> = v__604.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping664_hashtag__var_482) && (encdec_reg_backwards_matches(mapping665_hashtag__var_481) && encdec_reg_backwards_matches(mapping666_hashtag__var_480))) && ((v__604.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0011011)) && ((v__604.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__604.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping666_hashtag_: BitVector<5> = v__604.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping665_hashtag_: BitVector<5> = v__604.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping664_hashtag_: BitVector<5> = v__604.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping664_hashtag_), encdec_reg_backwards(mapping665_hashtag_), encdec_reg_backwards(mapping666_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zkne)} => {Some(ast::AES64ESM((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__599 if {let mapping669_hashtag__var_477: BitVector<5> = v__599.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping668_hashtag__var_478: BitVector<5> = v__599.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping667_hashtag__var_479: BitVector<5> = v__599.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping667_hashtag__var_479) && (encdec_reg_backwards_matches(mapping668_hashtag__var_478) && encdec_reg_backwards_matches(mapping669_hashtag__var_477))) && ((v__599.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0011001)) && ((v__599.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__599.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping669_hashtag_: BitVector<5> = v__599.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping668_hashtag_: BitVector<5> = v__599.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping667_hashtag_: BitVector<5> = v__599.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping667_hashtag_), encdec_reg_backwards(mapping668_hashtag_), encdec_reg_backwards(mapping669_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zkne)} => {Some(ast::AES64ES((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__594 if {let mapping672_hashtag__var_474: BitVector<5> = v__594.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping671_hashtag__var_475: BitVector<5> = v__594.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping670_hashtag__var_476: BitVector<5> = v__594.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping670_hashtag__var_476) && (encdec_reg_backwards_matches(mapping671_hashtag__var_475) && encdec_reg_backwards_matches(mapping672_hashtag__var_474))) && ((v__594.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0011111)) && ((v__594.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__594.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping672_hashtag_: BitVector<5> = v__594.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping671_hashtag_: BitVector<5> = v__594.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping670_hashtag_: BitVector<5> = v__594.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping670_hashtag_), encdec_reg_backwards(mapping671_hashtag_), encdec_reg_backwards(mapping672_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {Some(ast::AES64DSM((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__589 if {let mapping675_hashtag__var_471: BitVector<5> = v__589.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping674_hashtag__var_472: BitVector<5> = v__589.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping673_hashtag__var_473: BitVector<5> = v__589.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping673_hashtag__var_473) && (encdec_reg_backwards_matches(mapping674_hashtag__var_472) && encdec_reg_backwards_matches(mapping675_hashtag__var_471))) && ((v__589.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0011101)) && ((v__589.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__589.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping675_hashtag_: BitVector<5> = v__589.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping674_hashtag_: BitVector<5> = v__589.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping673_hashtag_: BitVector<5> = v__589.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping673_hashtag_), encdec_reg_backwards(mapping674_hashtag_), encdec_reg_backwards(mapping675_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknd)} => {Some(ast::AES64DS((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__583 if {let mapping677_hashtag__var_469: BitVector<5> = v__583.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping676_hashtag__var_470: BitVector<5> = v__583.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping676_hashtag__var_470) && encdec_reg_backwards_matches(mapping677_hashtag__var_469)) && ((v__583.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000100)) && ((v__583.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__583.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping677_hashtag_: BitVector<5> = v__583.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping676_hashtag_: BitVector<5> = v__583.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping676_hashtag_), encdec_reg_backwards(mapping677_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA512SUM0((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__577 if {let mapping679_hashtag__var_467: BitVector<5> = v__577.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping678_hashtag__var_468: BitVector<5> = v__577.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping678_hashtag__var_468) && encdec_reg_backwards_matches(mapping679_hashtag__var_467)) && ((v__577.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000101)) && ((v__577.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__577.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping679_hashtag_: BitVector<5> = v__577.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping678_hashtag_: BitVector<5> = v__577.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping678_hashtag_), encdec_reg_backwards(mapping679_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA512SUM1((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__571 if {let mapping681_hashtag__var_465: BitVector<5> = v__571.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping680_hashtag__var_466: BitVector<5> = v__571.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping680_hashtag__var_466) && encdec_reg_backwards_matches(mapping681_hashtag__var_465)) && ((v__571.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000110)) && ((v__571.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__571.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping681_hashtag_: BitVector<5> = v__571.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping680_hashtag_: BitVector<5> = v__571.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping680_hashtag_), encdec_reg_backwards(mapping681_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA512SIG0((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__565 if {let mapping683_hashtag__var_463: BitVector<5> = v__565.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping682_hashtag__var_464: BitVector<5> = v__565.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping682_hashtag__var_464) && encdec_reg_backwards_matches(mapping683_hashtag__var_463)) && ((v__565.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100000111)) && ((v__565.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__565.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping683_hashtag_: BitVector<5> = v__565.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping682_hashtag_: BitVector<5> = v__565.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping682_hashtag_), encdec_reg_backwards(mapping683_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zknh)} => {Some(ast::SHA512SIG1((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__559 if {let mapping685_hashtag__var_461: BitVector<5> = v__559.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping684_hashtag__var_462: BitVector<5> = v__559.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping684_hashtag__var_462) && encdec_reg_backwards_matches(mapping685_hashtag__var_461)) && ((v__559.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100001000)) && ((v__559.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__559.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping685_hashtag_: BitVector<5> = v__559.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping684_hashtag_: BitVector<5> = v__559.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping684_hashtag_), encdec_reg_backwards(mapping685_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zksh)} => {Some(ast::SM3P0((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__553 if {let mapping687_hashtag__var_459: BitVector<5> = v__553.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping686_hashtag__var_460: BitVector<5> = v__553.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping686_hashtag__var_460) && encdec_reg_backwards_matches(mapping687_hashtag__var_459)) && ((v__553.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000100001001)) && ((v__553.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__553.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping687_hashtag_: BitVector<5> = v__553.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping686_hashtag_: BitVector<5> = v__553.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping686_hashtag_), encdec_reg_backwards(mapping687_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zksh)} => {Some(ast::SM3P1((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__549 if {let mapping690_hashtag__var_456: BitVector<5> = v__549.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping689_hashtag__var_457: BitVector<5> = v__549.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping688_hashtag__var_458: BitVector<5> = v__549.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping688_hashtag__var_458) && (encdec_reg_backwards_matches(mapping689_hashtag__var_457) && encdec_reg_backwards_matches(mapping690_hashtag__var_456))) && ((v__549.subrange::<25, 30, 5>() == BitVector::<5>::new(0b11000)) && ((v__549.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__549.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__549.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping690_hashtag_: BitVector<5> = v__549.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping689_hashtag_: BitVector<5> = v__549.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping688_hashtag_: BitVector<5> = v__549.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let bs: BitVector<2> = v__549.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping688_hashtag_), encdec_reg_backwards(mapping689_hashtag_), encdec_reg_backwards(mapping690_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zksed)} => {Some(ast::SM4ED((bs, rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__545 if {let mapping693_hashtag__var_453: BitVector<5> = v__545.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping692_hashtag__var_454: BitVector<5> = v__545.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping691_hashtag__var_455: BitVector<5> = v__545.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping691_hashtag__var_455) && (encdec_reg_backwards_matches(mapping692_hashtag__var_454) && encdec_reg_backwards_matches(mapping693_hashtag__var_453))) && ((v__545.subrange::<25, 30, 5>() == BitVector::<5>::new(0b11010)) && ((v__545.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__545.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let bs: BitVector<2> = v__545.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping693_hashtag_: BitVector<5> = v__545.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping692_hashtag_: BitVector<5> = v__545.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping691_hashtag_: BitVector<5> = v__545.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let bs: BitVector<2> = v__545.subrange::<30, 32, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping691_hashtag_), encdec_reg_backwards(mapping692_hashtag_), encdec_reg_backwards(mapping693_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zksed)} => {Some(ast::SM4KS((bs, rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__541 if {let mapping696_hashtag__var_450: BitVector<5> = v__541.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping695_hashtag__var_451: BitVector<5> = v__541.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping694_hashtag__var_452: BitVector<5> = v__541.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping694_hashtag__var_452) && (encdec_reg_backwards_matches(mapping695_hashtag__var_451) && encdec_reg_backwards_matches(mapping696_hashtag__var_450))) && ((v__541.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000100)) && ((v__541.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__541.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping696_hashtag_: BitVector<5> = v__541.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping695_hashtag_: BitVector<5> = v__541.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping694_hashtag_: BitVector<5> = v__541.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping694_hashtag_), encdec_reg_backwards(mapping695_hashtag_), encdec_reg_backwards(mapping696_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {Some(ast::ZBKB_RTYPE((rs2, rs1, rd, brop_zbkb::PACK)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__537 if {let mapping699_hashtag__var_447: BitVector<5> = v__537.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping698_hashtag__var_448: BitVector<5> = v__537.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping697_hashtag__var_449: BitVector<5> = v__537.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping697_hashtag__var_449) && (encdec_reg_backwards_matches(mapping698_hashtag__var_448) && encdec_reg_backwards_matches(mapping699_hashtag__var_447))) && ((v__537.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000100)) && ((v__537.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__537.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping699_hashtag_: BitVector<5> = v__537.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping698_hashtag_: BitVector<5> = v__537.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping697_hashtag_: BitVector<5> = v__537.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping697_hashtag_), encdec_reg_backwards(mapping698_hashtag_), encdec_reg_backwards(mapping699_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {Some(ast::ZBKB_RTYPE((rs2, rs1, rd, brop_zbkb::PACKH)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__533 if {let mapping702_hashtag__var_444: BitVector<5> = v__533.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping701_hashtag__var_445: BitVector<5> = v__533.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping700_hashtag__var_446: BitVector<5> = v__533.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping700_hashtag__var_446) && (encdec_reg_backwards_matches(mapping701_hashtag__var_445) && encdec_reg_backwards_matches(mapping702_hashtag__var_444))) && ((v__533.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000100)) && ((v__533.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__533.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0111011)))))} => {let mapping702_hashtag_: BitVector<5> = v__533.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping701_hashtag_: BitVector<5> = v__533.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping700_hashtag_: BitVector<5> = v__533.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping700_hashtag_), encdec_reg_backwards(mapping701_hashtag_), encdec_reg_backwards(mapping702_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {Some(ast::ZBKB_PACKW((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__529 if {let mapping704_hashtag__var_442: BitVector<5> = v__529.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping703_hashtag__var_443: BitVector<5> = v__529.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping703_hashtag__var_443) && encdec_reg_backwards_matches(mapping704_hashtag__var_442)) && ((v__529.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000010001111)) && ((v__529.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__529.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping704_hashtag_: BitVector<5> = v__529.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping703_hashtag_: BitVector<5> = v__529.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__525 if {let mapping706_hashtag__var_440: BitVector<5> = v__525.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping705_hashtag__var_441: BitVector<5> = v__525.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping705_hashtag__var_441) && encdec_reg_backwards_matches(mapping706_hashtag__var_440)) && ((v__525.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000010001111)) && ((v__525.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__525.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping706_hashtag_: BitVector<5> = v__525.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping705_hashtag_: BitVector<5> = v__525.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__521 if {let mapping708_hashtag__var_438: BitVector<5> = v__521.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping707_hashtag__var_439: BitVector<5> = v__521.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping707_hashtag__var_439) && encdec_reg_backwards_matches(mapping708_hashtag__var_438)) && ((v__521.subrange::<20, 32, 12>() == BitVector::<12>::new(0b011010000111)) && ((v__521.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__521.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0010011)))))} => {let mapping708_hashtag_: BitVector<5> = v__521.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping707_hashtag_: BitVector<5> = v__521.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping707_hashtag_), encdec_reg_backwards(mapping708_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkb)} => {Some(ast::BREV8((rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__517 if {let mapping711_hashtag__var_435: BitVector<5> = v__517.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping710_hashtag__var_436: BitVector<5> = v__517.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping709_hashtag__var_437: BitVector<5> = v__517.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping709_hashtag__var_437) && (encdec_reg_backwards_matches(mapping710_hashtag__var_436) && encdec_reg_backwards_matches(mapping711_hashtag__var_435))) && ((v__517.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__517.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__517.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping711_hashtag_: BitVector<5> = v__517.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping710_hashtag_: BitVector<5> = v__517.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping709_hashtag_: BitVector<5> = v__517.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping709_hashtag_), encdec_reg_backwards(mapping710_hashtag_), encdec_reg_backwards(mapping711_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkx)} => {Some(ast::XPERM8((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__513 if {let mapping714_hashtag__var_432: BitVector<5> = v__513.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping713_hashtag__var_433: BitVector<5> = v__513.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping712_hashtag__var_434: BitVector<5> = v__513.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping712_hashtag__var_434) && (encdec_reg_backwards_matches(mapping713_hashtag__var_433) && encdec_reg_backwards_matches(mapping714_hashtag__var_432))) && ((v__513.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0010100)) && ((v__513.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__513.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping714_hashtag_: BitVector<5> = v__513.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping713_hashtag_: BitVector<5> = v__513.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping712_hashtag_: BitVector<5> = v__513.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping712_hashtag_), encdec_reg_backwards(mapping713_hashtag_), encdec_reg_backwards(mapping714_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zbkx)} => {Some(ast::XPERM4((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__509 if {let mapping717_hashtag__var_429: BitVector<5> = v__509.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping716_hashtag__var_430: BitVector<5> = v__509.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping715_hashtag__var_431: BitVector<5> = v__509.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping715_hashtag__var_431) && (encdec_reg_backwards_matches(mapping716_hashtag__var_430) && encdec_reg_backwards_matches(mapping717_hashtag__var_429))) && ((v__509.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000111)) && ((v__509.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__509.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping717_hashtag_: BitVector<5> = v__509.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping716_hashtag_: BitVector<5> = v__509.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping715_hashtag_: BitVector<5> = v__509.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping715_hashtag_), encdec_reg_backwards(mapping716_hashtag_), encdec_reg_backwards(mapping717_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zicond)} => {Some(ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_EQZ)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__505 if {let mapping720_hashtag__var_426: BitVector<5> = v__505.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping719_hashtag__var_427: BitVector<5> = v__505.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping718_hashtag__var_428: BitVector<5> = v__505.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping718_hashtag__var_428) && (encdec_reg_backwards_matches(mapping719_hashtag__var_427) && encdec_reg_backwards_matches(mapping720_hashtag__var_426))) && ((v__505.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0000111)) && ((v__505.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__505.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0110011)))))} => {let mapping720_hashtag_: BitVector<5> = v__505.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping719_hashtag_: BitVector<5> = v__505.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping718_hashtag_: BitVector<5> = v__505.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping718_hashtag_), encdec_reg_backwards(mapping719_hashtag_), encdec_reg_backwards(mapping720_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zicond)} => {Some(ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_NEZ)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__501 if {let mapping722_hashtag__var_424: BitVector<5> = v__501.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping721_hashtag__var_425: BitVector<5> = v__501.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping721_hashtag__var_425) && encdec_reg_backwards_matches(mapping722_hashtag__var_424)) && ((v__501.subrange::<28, 32, 4>() == BitVector::<4>::new(0b0000)) && ((v__501.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__501.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let ta: BitVector<1> = v__501.subrange::<26, 27, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let sew: BitVector<3> = v__501.subrange::<23, 26, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping722_hashtag_: BitVector<5> = v__501.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping721_hashtag_: BitVector<5> = v__501.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let ma: BitVector<1> = v__501.subrange::<27, 28, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let lmul: BitVector<3> = v__501.subrange::<20, 23, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping721_hashtag_), encdec_reg_backwards(mapping722_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSETVLI((ma, ta, sew, lmul, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__497 if {let mapping725_hashtag__var_421: BitVector<5> = v__497.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping724_hashtag__var_422: BitVector<5> = v__497.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping723_hashtag__var_423: BitVector<5> = v__497.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping723_hashtag__var_423) && (encdec_reg_backwards_matches(mapping724_hashtag__var_422) && encdec_reg_backwards_matches(mapping725_hashtag__var_421))) && ((v__497.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1000000)) && ((v__497.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__497.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping725_hashtag_: BitVector<5> = v__497.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping724_hashtag_: BitVector<5> = v__497.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping723_hashtag_: BitVector<5> = v__497.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping723_hashtag_), encdec_reg_backwards(mapping724_hashtag_), encdec_reg_backwards(mapping725_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSETVL((rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__493 if {let mapping726_hashtag__var_420: BitVector<5> = v__493.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (encdec_reg_backwards_matches(mapping726_hashtag__var_420) && ((v__493.subrange::<28, 32, 4>() == BitVector::<4>::new(0b1100)) && ((v__493.subrange::<12, 15, 3>() == BitVector::<3>::new(0b111)) && (v__493.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let uimm: BitVector<5> = v__493.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let ta: BitVector<1> = v__493.subrange::<26, 27, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let sew: BitVector<3> = v__493.subrange::<23, 26, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping726_hashtag_: BitVector<5> = v__493.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let ma: BitVector<1> = v__493.subrange::<27, 28, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let lmul: BitVector<3> = v__493.subrange::<20, 23, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match encdec_reg_backwards(mapping726_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rd if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSETIVLI((ma, ta, sew, lmul, uimm, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__490 if {let mapping727_hashtag__var_415: BitVector<6> = v__490.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping730_hashtag__var_416: BitVector<5> = v__490.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping729_hashtag__var_417: BitVector<5> = v__490.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping728_hashtag__var_418: BitVector<5> = v__490.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping727_hashtag__var_419: BitVector<6> = v__490.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vvfunct6_backwards_matches(mapping727_hashtag__var_419) && (encdec_vreg_backwards_matches(mapping728_hashtag__var_418) && (encdec_vreg_backwards_matches(mapping729_hashtag__var_417) && encdec_vreg_backwards_matches(mapping730_hashtag__var_416)))) && ((v__490.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__490.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping727_hashtag_: BitVector<6> = v__490.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__490.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping730_hashtag_: BitVector<5> = v__490.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping729_hashtag_: BitVector<5> = v__490.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping728_hashtag_: BitVector<5> = v__490.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping727_hashtag_: BitVector<6> = v__490.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vvfunct6_backwards(mapping727_hashtag_), encdec_vreg_backwards(mapping728_hashtag_), encdec_vreg_backwards(mapping729_hashtag_), encdec_vreg_backwards(mapping730_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__487 if {let mapping731_hashtag__var_410: BitVector<6> = v__487.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping734_hashtag__var_411: BitVector<5> = v__487.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping733_hashtag__var_412: BitVector<5> = v__487.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping732_hashtag__var_413: BitVector<5> = v__487.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping731_hashtag__var_414: BitVector<6> = v__487.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_nvsfunct6_backwards_matches(mapping731_hashtag__var_414) && (encdec_vreg_backwards_matches(mapping732_hashtag__var_413) && (encdec_vreg_backwards_matches(mapping733_hashtag__var_412) && encdec_vreg_backwards_matches(mapping734_hashtag__var_411)))) && ((v__487.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__487.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping731_hashtag_: BitVector<6> = v__487.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__487.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping734_hashtag_: BitVector<5> = v__487.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping733_hashtag_: BitVector<5> = v__487.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping732_hashtag_: BitVector<5> = v__487.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping731_hashtag_: BitVector<6> = v__487.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_nvsfunct6_backwards(mapping731_hashtag_), encdec_vreg_backwards(mapping732_hashtag_), encdec_vreg_backwards(mapping733_hashtag_), encdec_vreg_backwards(mapping734_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NVSTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__484 if {let mapping735_hashtag__var_405: BitVector<6> = v__484.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping738_hashtag__var_406: BitVector<5> = v__484.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping737_hashtag__var_407: BitVector<5> = v__484.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping736_hashtag__var_408: BitVector<5> = v__484.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping735_hashtag__var_409: BitVector<6> = v__484.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_nvfunct6_backwards_matches(mapping735_hashtag__var_409) && (encdec_vreg_backwards_matches(mapping736_hashtag__var_408) && (encdec_vreg_backwards_matches(mapping737_hashtag__var_407) && encdec_vreg_backwards_matches(mapping738_hashtag__var_406)))) && ((v__484.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__484.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping735_hashtag_: BitVector<6> = v__484.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__484.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping738_hashtag_: BitVector<5> = v__484.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping737_hashtag_: BitVector<5> = v__484.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping736_hashtag_: BitVector<5> = v__484.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping735_hashtag_: BitVector<6> = v__484.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_nvfunct6_backwards(mapping735_hashtag_), encdec_vreg_backwards(mapping736_hashtag_), encdec_vreg_backwards(mapping737_hashtag_), encdec_vreg_backwards(mapping738_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__479 if {let mapping741_hashtag__var_402: BitVector<5> = v__479.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping740_hashtag__var_403: BitVector<5> = v__479.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping739_hashtag__var_404: BitVector<5> = v__479.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping739_hashtag__var_404) && (encdec_vreg_backwards_matches(mapping740_hashtag__var_403) && encdec_vreg_backwards_matches(mapping741_hashtag__var_402))) && ((v__479.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101110)) && ((v__479.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__479.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping741_hashtag_: BitVector<5> = v__479.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping740_hashtag_: BitVector<5> = v__479.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping739_hashtag_: BitVector<5> = v__479.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping739_hashtag_), encdec_vreg_backwards(mapping740_hashtag_), encdec_vreg_backwards(mapping741_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MASKTYPEV((vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__473 if {let mapping743_hashtag__var_400: BitVector<5> = v__473.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping742_hashtag__var_401: BitVector<5> = v__473.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping742_hashtag__var_401) && encdec_vreg_backwards_matches(mapping743_hashtag__var_400)) && ((v__473.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010111100000)) && ((v__473.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__473.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping743_hashtag_: BitVector<5> = v__473.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping742_hashtag_: BitVector<5> = v__473.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping742_hashtag_), encdec_vreg_backwards(mapping743_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MOVETYPEV((vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__470 if {let mapping744_hashtag__var_395: BitVector<6> = v__470.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping747_hashtag__var_396: BitVector<5> = v__470.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping746_hashtag__var_397: BitVector<5> = v__470.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping745_hashtag__var_398: BitVector<5> = v__470.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping744_hashtag__var_399: BitVector<6> = v__470.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vxfunct6_backwards_matches(mapping744_hashtag__var_399) && (encdec_vreg_backwards_matches(mapping745_hashtag__var_398) && (encdec_reg_backwards_matches(mapping746_hashtag__var_397) && encdec_vreg_backwards_matches(mapping747_hashtag__var_396)))) && ((v__470.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__470.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping744_hashtag_: BitVector<6> = v__470.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__470.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping747_hashtag_: BitVector<5> = v__470.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping746_hashtag_: BitVector<5> = v__470.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping745_hashtag_: BitVector<5> = v__470.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping744_hashtag_: BitVector<6> = v__470.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vxfunct6_backwards(mapping744_hashtag_), encdec_vreg_backwards(mapping745_hashtag_), encdec_reg_backwards(mapping746_hashtag_), encdec_vreg_backwards(mapping747_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__467 if {let mapping748_hashtag__var_390: BitVector<6> = v__467.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping751_hashtag__var_391: BitVector<5> = v__467.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping750_hashtag__var_392: BitVector<5> = v__467.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping749_hashtag__var_393: BitVector<5> = v__467.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping748_hashtag__var_394: BitVector<6> = v__467.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_nxsfunct6_backwards_matches(mapping748_hashtag__var_394) && (encdec_vreg_backwards_matches(mapping749_hashtag__var_393) && (encdec_reg_backwards_matches(mapping750_hashtag__var_392) && encdec_vreg_backwards_matches(mapping751_hashtag__var_391)))) && ((v__467.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__467.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping748_hashtag_: BitVector<6> = v__467.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__467.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping751_hashtag_: BitVector<5> = v__467.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping750_hashtag_: BitVector<5> = v__467.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping749_hashtag_: BitVector<5> = v__467.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping748_hashtag_: BitVector<6> = v__467.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_nxsfunct6_backwards(mapping748_hashtag_), encdec_vreg_backwards(mapping749_hashtag_), encdec_reg_backwards(mapping750_hashtag_), encdec_vreg_backwards(mapping751_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NXSTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__464 if {let mapping752_hashtag__var_385: BitVector<6> = v__464.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping755_hashtag__var_386: BitVector<5> = v__464.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping754_hashtag__var_387: BitVector<5> = v__464.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping753_hashtag__var_388: BitVector<5> = v__464.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping752_hashtag__var_389: BitVector<6> = v__464.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_nxfunct6_backwards_matches(mapping752_hashtag__var_389) && (encdec_vreg_backwards_matches(mapping753_hashtag__var_388) && (encdec_reg_backwards_matches(mapping754_hashtag__var_387) && encdec_vreg_backwards_matches(mapping755_hashtag__var_386)))) && ((v__464.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__464.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping752_hashtag_: BitVector<6> = v__464.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__464.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping755_hashtag_: BitVector<5> = v__464.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping754_hashtag_: BitVector<5> = v__464.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping753_hashtag_: BitVector<5> = v__464.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping752_hashtag_: BitVector<6> = v__464.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_nxfunct6_backwards(mapping752_hashtag_), encdec_vreg_backwards(mapping753_hashtag_), encdec_reg_backwards(mapping754_hashtag_), encdec_vreg_backwards(mapping755_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__461 if {let mapping756_hashtag__var_380: BitVector<6> = v__461.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping759_hashtag__var_381: BitVector<5> = v__461.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping758_hashtag__var_382: BitVector<5> = v__461.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping757_hashtag__var_383: BitVector<5> = v__461.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping756_hashtag__var_384: BitVector<6> = v__461.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vxsgfunct6_backwards_matches(mapping756_hashtag__var_384) && (encdec_vreg_backwards_matches(mapping757_hashtag__var_383) && (encdec_reg_backwards_matches(mapping758_hashtag__var_382) && encdec_vreg_backwards_matches(mapping759_hashtag__var_381)))) && ((v__461.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__461.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping756_hashtag_: BitVector<6> = v__461.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__461.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping759_hashtag_: BitVector<5> = v__461.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping758_hashtag_: BitVector<5> = v__461.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping757_hashtag_: BitVector<5> = v__461.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping756_hashtag_: BitVector<6> = v__461.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vxsgfunct6_backwards(mapping756_hashtag_), encdec_vreg_backwards(mapping757_hashtag_), encdec_reg_backwards(mapping758_hashtag_), encdec_vreg_backwards(mapping759_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXSG((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__456 if {let mapping762_hashtag__var_377: BitVector<5> = v__456.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping761_hashtag__var_378: BitVector<5> = v__456.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping760_hashtag__var_379: BitVector<5> = v__456.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping760_hashtag__var_379) && (encdec_reg_backwards_matches(mapping761_hashtag__var_378) && encdec_vreg_backwards_matches(mapping762_hashtag__var_377))) && ((v__456.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101110)) && ((v__456.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__456.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping762_hashtag_: BitVector<5> = v__456.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping761_hashtag_: BitVector<5> = v__456.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping760_hashtag_: BitVector<5> = v__456.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping760_hashtag_), encdec_reg_backwards(mapping761_hashtag_), encdec_vreg_backwards(mapping762_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MASKTYPEX((vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__450 if {let mapping764_hashtag__var_375: BitVector<5> = v__450.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping763_hashtag__var_376: BitVector<5> = v__450.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping763_hashtag__var_376) && encdec_vreg_backwards_matches(mapping764_hashtag__var_375)) && ((v__450.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010111100000)) && ((v__450.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__450.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping764_hashtag_: BitVector<5> = v__450.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping763_hashtag_: BitVector<5> = v__450.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping763_hashtag_), encdec_vreg_backwards(mapping764_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MOVETYPEX((rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__447 if {let mapping765_hashtag__var_371: BitVector<6> = v__447.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping767_hashtag__var_372: BitVector<5> = v__447.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping766_hashtag__var_373: BitVector<5> = v__447.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping765_hashtag__var_374: BitVector<6> = v__447.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vifunct6_backwards_matches(mapping765_hashtag__var_374) && (encdec_vreg_backwards_matches(mapping766_hashtag__var_373) && encdec_vreg_backwards_matches(mapping767_hashtag__var_372))) && ((v__447.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__447.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping765_hashtag_: BitVector<6> = v__447.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__447.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let simm: BitVector<5> = v__447.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping767_hashtag_: BitVector<5> = v__447.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping766_hashtag_: BitVector<5> = v__447.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping765_hashtag_: BitVector<6> = v__447.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vifunct6_backwards(mapping765_hashtag_), encdec_vreg_backwards(mapping766_hashtag_), encdec_vreg_backwards(mapping767_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VITYPE((funct6, vm, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__444 if {let mapping768_hashtag__var_367: BitVector<6> = v__444.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping770_hashtag__var_368: BitVector<5> = v__444.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping769_hashtag__var_369: BitVector<5> = v__444.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping768_hashtag__var_370: BitVector<6> = v__444.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_nisfunct6_backwards_matches(mapping768_hashtag__var_370) && (encdec_vreg_backwards_matches(mapping769_hashtag__var_369) && encdec_vreg_backwards_matches(mapping770_hashtag__var_368))) && ((v__444.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__444.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping768_hashtag_: BitVector<6> = v__444.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__444.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let simm: BitVector<5> = v__444.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping770_hashtag_: BitVector<5> = v__444.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping769_hashtag_: BitVector<5> = v__444.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping768_hashtag_: BitVector<6> = v__444.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_nisfunct6_backwards(mapping768_hashtag_), encdec_vreg_backwards(mapping769_hashtag_), encdec_vreg_backwards(mapping770_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NISTYPE((funct6, vm, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__441 if {let mapping771_hashtag__var_363: BitVector<6> = v__441.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping773_hashtag__var_364: BitVector<5> = v__441.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping772_hashtag__var_365: BitVector<5> = v__441.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping771_hashtag__var_366: BitVector<6> = v__441.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_nifunct6_backwards_matches(mapping771_hashtag__var_366) && (encdec_vreg_backwards_matches(mapping772_hashtag__var_365) && encdec_vreg_backwards_matches(mapping773_hashtag__var_364))) && ((v__441.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__441.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping771_hashtag_: BitVector<6> = v__441.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__441.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let simm: BitVector<5> = v__441.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping773_hashtag_: BitVector<5> = v__441.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping772_hashtag_: BitVector<5> = v__441.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping771_hashtag_: BitVector<6> = v__441.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_nifunct6_backwards(mapping771_hashtag_), encdec_vreg_backwards(mapping772_hashtag_), encdec_vreg_backwards(mapping773_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::NITYPE((funct6, vm, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__438 if {let mapping774_hashtag__var_359: BitVector<6> = v__438.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping776_hashtag__var_360: BitVector<5> = v__438.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping775_hashtag__var_361: BitVector<5> = v__438.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping774_hashtag__var_362: BitVector<6> = v__438.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_visgfunct6_backwards_matches(mapping774_hashtag__var_362) && (encdec_vreg_backwards_matches(mapping775_hashtag__var_361) && encdec_vreg_backwards_matches(mapping776_hashtag__var_360))) && ((v__438.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__438.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping774_hashtag_: BitVector<6> = v__438.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__438.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let simm: BitVector<5> = v__438.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping776_hashtag_: BitVector<5> = v__438.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping775_hashtag_: BitVector<5> = v__438.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping774_hashtag_: BitVector<6> = v__438.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_visgfunct6_backwards(mapping774_hashtag_), encdec_vreg_backwards(mapping775_hashtag_), encdec_vreg_backwards(mapping776_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VISG((funct6, vm, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__433 if {let mapping778_hashtag__var_357: BitVector<5> = v__433.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping777_hashtag__var_358: BitVector<5> = v__433.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping777_hashtag__var_358) && encdec_vreg_backwards_matches(mapping778_hashtag__var_357)) && ((v__433.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101110)) && ((v__433.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__433.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let simm: BitVector<5> = v__433.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping778_hashtag_: BitVector<5> = v__433.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping777_hashtag_: BitVector<5> = v__433.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping777_hashtag_), encdec_vreg_backwards(mapping778_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MASKTYPEI((vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__427 if {let mapping779_hashtag__var_356: BitVector<5> = v__427.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (encdec_vreg_backwards_matches(mapping779_hashtag__var_356) && ((v__427.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010111100000)) && ((v__427.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__427.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let simm: BitVector<5> = v__427.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping779_hashtag_: BitVector<5> = v__427.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match encdec_vreg_backwards(mapping779_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        vd if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MOVETYPEI((vd, simm)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__422 if {let mapping781_hashtag__var_354: BitVector<5> = v__422.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping780_hashtag__var_355: BitVector<5> = v__422.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping780_hashtag__var_355) && encdec_vreg_backwards_matches(mapping781_hashtag__var_354)) && ((v__422.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1001111)) && ((v__422.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__422.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let simm: BitVector<5> = v__422.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping781_hashtag_: BitVector<5> = v__422.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping780_hashtag_: BitVector<5> = v__422.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping780_hashtag_), encdec_vreg_backwards(mapping781_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMVRTYPE((vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__419 if {let mapping782_hashtag__var_349: BitVector<6> = v__419.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping785_hashtag__var_350: BitVector<5> = v__419.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping784_hashtag__var_351: BitVector<5> = v__419.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping783_hashtag__var_352: BitVector<5> = v__419.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping782_hashtag__var_353: BitVector<6> = v__419.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_mvvfunct6_backwards_matches(mapping782_hashtag__var_353) && (encdec_vreg_backwards_matches(mapping783_hashtag__var_352) && (encdec_vreg_backwards_matches(mapping784_hashtag__var_351) && encdec_vreg_backwards_matches(mapping785_hashtag__var_350)))) && ((v__419.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__419.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping782_hashtag_: BitVector<6> = v__419.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__419.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping785_hashtag_: BitVector<5> = v__419.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping784_hashtag_: BitVector<5> = v__419.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping783_hashtag_: BitVector<5> = v__419.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping782_hashtag_: BitVector<6> = v__419.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_mvvfunct6_backwards(mapping782_hashtag_), encdec_vreg_backwards(mapping783_hashtag_), encdec_vreg_backwards(mapping784_hashtag_), encdec_vreg_backwards(mapping785_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__416 if {let mapping786_hashtag__var_344: BitVector<6> = v__416.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping789_hashtag__var_345: BitVector<5> = v__416.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping788_hashtag__var_346: BitVector<5> = v__416.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping787_hashtag__var_347: BitVector<5> = v__416.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping786_hashtag__var_348: BitVector<6> = v__416.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_mvvmafunct6_backwards_matches(mapping786_hashtag__var_348) && (encdec_vreg_backwards_matches(mapping787_hashtag__var_347) && (encdec_vreg_backwards_matches(mapping788_hashtag__var_346) && encdec_vreg_backwards_matches(mapping789_hashtag__var_345)))) && ((v__416.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__416.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping786_hashtag_: BitVector<6> = v__416.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__416.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping789_hashtag_: BitVector<5> = v__416.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping788_hashtag_: BitVector<5> = v__416.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping787_hashtag_: BitVector<5> = v__416.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping786_hashtag_: BitVector<6> = v__416.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_mvvmafunct6_backwards(mapping786_hashtag_), encdec_vreg_backwards(mapping787_hashtag_), encdec_vreg_backwards(mapping788_hashtag_), encdec_vreg_backwards(mapping789_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MVVMATYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__413 if {let mapping790_hashtag__var_339: BitVector<6> = v__413.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping793_hashtag__var_340: BitVector<5> = v__413.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping792_hashtag__var_341: BitVector<5> = v__413.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping791_hashtag__var_342: BitVector<5> = v__413.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping790_hashtag__var_343: BitVector<6> = v__413.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_wvvfunct6_backwards_matches(mapping790_hashtag__var_343) && (encdec_vreg_backwards_matches(mapping791_hashtag__var_342) && (encdec_vreg_backwards_matches(mapping792_hashtag__var_341) && encdec_vreg_backwards_matches(mapping793_hashtag__var_340)))) && ((v__413.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__413.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping790_hashtag_: BitVector<6> = v__413.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__413.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping793_hashtag_: BitVector<5> = v__413.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping792_hashtag_: BitVector<5> = v__413.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping791_hashtag_: BitVector<5> = v__413.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping790_hashtag_: BitVector<6> = v__413.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_wvvfunct6_backwards(mapping790_hashtag_), encdec_vreg_backwards(mapping791_hashtag_), encdec_vreg_backwards(mapping792_hashtag_), encdec_vreg_backwards(mapping793_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__410 if {let mapping794_hashtag__var_334: BitVector<6> = v__410.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping797_hashtag__var_335: BitVector<5> = v__410.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping796_hashtag__var_336: BitVector<5> = v__410.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping795_hashtag__var_337: BitVector<5> = v__410.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping794_hashtag__var_338: BitVector<6> = v__410.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_wvfunct6_backwards_matches(mapping794_hashtag__var_338) && (encdec_vreg_backwards_matches(mapping795_hashtag__var_337) && (encdec_vreg_backwards_matches(mapping796_hashtag__var_336) && encdec_vreg_backwards_matches(mapping797_hashtag__var_335)))) && ((v__410.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__410.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping794_hashtag_: BitVector<6> = v__410.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__410.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping797_hashtag_: BitVector<5> = v__410.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping796_hashtag_: BitVector<5> = v__410.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping795_hashtag_: BitVector<5> = v__410.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping794_hashtag_: BitVector<6> = v__410.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_wvfunct6_backwards(mapping794_hashtag_), encdec_vreg_backwards(mapping795_hashtag_), encdec_vreg_backwards(mapping796_hashtag_), encdec_vreg_backwards(mapping797_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__407 if {let mapping798_hashtag__var_329: BitVector<6> = v__407.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping801_hashtag__var_330: BitVector<5> = v__407.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping800_hashtag__var_331: BitVector<5> = v__407.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping799_hashtag__var_332: BitVector<5> = v__407.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping798_hashtag__var_333: BitVector<6> = v__407.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_wmvvfunct6_backwards_matches(mapping798_hashtag__var_333) && (encdec_vreg_backwards_matches(mapping799_hashtag__var_332) && (encdec_vreg_backwards_matches(mapping800_hashtag__var_331) && encdec_vreg_backwards_matches(mapping801_hashtag__var_330)))) && ((v__407.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__407.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping798_hashtag_: BitVector<6> = v__407.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__407.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping801_hashtag_: BitVector<5> = v__407.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping800_hashtag_: BitVector<5> = v__407.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping799_hashtag_: BitVector<5> = v__407.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping798_hashtag_: BitVector<6> = v__407.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_wmvvfunct6_backwards(mapping798_hashtag_), encdec_vreg_backwards(mapping799_hashtag_), encdec_vreg_backwards(mapping800_hashtag_), encdec_vreg_backwards(mapping801_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WMVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__403 if {let mapping804_hashtag__var_326: BitVector<5> = v__403.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping803_hashtag__var_327: BitVector<5> = v__403.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping802_hashtag__var_328: BitVector<5> = v__403.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping802_hashtag__var_328) && (vext2_vs1_backwards_matches(mapping803_hashtag__var_327) && encdec_vreg_backwards_matches(mapping804_hashtag__var_326))) && ((v__403.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__403.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__403.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__403.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping804_hashtag_: BitVector<5> = v__403.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping803_hashtag_: BitVector<5> = v__403.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping802_hashtag_: BitVector<5> = v__403.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping802_hashtag_), vext2_vs1_backwards(mapping803_hashtag_), encdec_vreg_backwards(mapping804_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, funct6, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VEXT2TYPE((funct6, vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__399 if {let mapping807_hashtag__var_323: BitVector<5> = v__399.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping806_hashtag__var_324: BitVector<5> = v__399.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping805_hashtag__var_325: BitVector<5> = v__399.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping805_hashtag__var_325) && (vext4_vs1_backwards_matches(mapping806_hashtag__var_324) && encdec_vreg_backwards_matches(mapping807_hashtag__var_323))) && ((v__399.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__399.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__399.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__399.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping807_hashtag_: BitVector<5> = v__399.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping806_hashtag_: BitVector<5> = v__399.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping805_hashtag_: BitVector<5> = v__399.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping805_hashtag_), vext4_vs1_backwards(mapping806_hashtag_), encdec_vreg_backwards(mapping807_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, funct6, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VEXT4TYPE((funct6, vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__395 if {let mapping810_hashtag__var_320: BitVector<5> = v__395.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping809_hashtag__var_321: BitVector<5> = v__395.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping808_hashtag__var_322: BitVector<5> = v__395.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping808_hashtag__var_322) && (vext8_vs1_backwards_matches(mapping809_hashtag__var_321) && encdec_vreg_backwards_matches(mapping810_hashtag__var_320))) && ((v__395.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__395.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__395.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__395.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping810_hashtag_: BitVector<5> = v__395.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping809_hashtag_: BitVector<5> = v__395.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping808_hashtag_: BitVector<5> = v__395.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping808_hashtag_), vext8_vs1_backwards(mapping809_hashtag_), encdec_vreg_backwards(mapping810_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, funct6, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VEXT8TYPE((funct6, vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__389 if {let mapping812_hashtag__var_318: BitVector<5> = v__389.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping811_hashtag__var_319: BitVector<5> = v__389.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping811_hashtag__var_319) && encdec_reg_backwards_matches(mapping812_hashtag__var_318)) && ((v__389.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100001)) && ((v__389.subrange::<12, 20, 8>() == BitVector::<8>::new(0b00000010)) && (v__389.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping812_hashtag_: BitVector<5> = v__389.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping811_hashtag_: BitVector<5> = v__389.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping811_hashtag_), encdec_reg_backwards(mapping812_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMVXS((vs2, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__384 if {let mapping815_hashtag__var_315: BitVector<5> = v__384.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping814_hashtag__var_316: BitVector<5> = v__384.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping813_hashtag__var_317: BitVector<5> = v__384.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping813_hashtag__var_317) && (encdec_vreg_backwards_matches(mapping814_hashtag__var_316) && encdec_vreg_backwards_matches(mapping815_hashtag__var_315))) && ((v__384.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101111)) && ((v__384.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__384.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping815_hashtag_: BitVector<5> = v__384.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping814_hashtag_: BitVector<5> = v__384.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping813_hashtag_: BitVector<5> = v__384.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping813_hashtag_), encdec_vreg_backwards(mapping814_hashtag_), encdec_vreg_backwards(mapping815_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MVVCOMPRESS((vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__381 if {let mapping816_hashtag__var_310: BitVector<6> = v__381.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping819_hashtag__var_311: BitVector<5> = v__381.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping818_hashtag__var_312: BitVector<5> = v__381.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping817_hashtag__var_313: BitVector<5> = v__381.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping816_hashtag__var_314: BitVector<6> = v__381.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_mvxfunct6_backwards_matches(mapping816_hashtag__var_314) && (encdec_vreg_backwards_matches(mapping817_hashtag__var_313) && (encdec_reg_backwards_matches(mapping818_hashtag__var_312) && encdec_vreg_backwards_matches(mapping819_hashtag__var_311)))) && ((v__381.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__381.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping816_hashtag_: BitVector<6> = v__381.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__381.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping819_hashtag_: BitVector<5> = v__381.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping818_hashtag_: BitVector<5> = v__381.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping817_hashtag_: BitVector<5> = v__381.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping816_hashtag_: BitVector<6> = v__381.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_mvxfunct6_backwards(mapping816_hashtag_), encdec_vreg_backwards(mapping817_hashtag_), encdec_reg_backwards(mapping818_hashtag_), encdec_vreg_backwards(mapping819_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MVXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__378 if {let mapping820_hashtag__var_305: BitVector<6> = v__378.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping823_hashtag__var_306: BitVector<5> = v__378.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping822_hashtag__var_307: BitVector<5> = v__378.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping821_hashtag__var_308: BitVector<5> = v__378.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping820_hashtag__var_309: BitVector<6> = v__378.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_mvxmafunct6_backwards_matches(mapping820_hashtag__var_309) && (encdec_vreg_backwards_matches(mapping821_hashtag__var_308) && (encdec_reg_backwards_matches(mapping822_hashtag__var_307) && encdec_vreg_backwards_matches(mapping823_hashtag__var_306)))) && ((v__378.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__378.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping820_hashtag_: BitVector<6> = v__378.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__378.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping823_hashtag_: BitVector<5> = v__378.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping822_hashtag_: BitVector<5> = v__378.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping821_hashtag_: BitVector<5> = v__378.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping820_hashtag_: BitVector<6> = v__378.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_mvxmafunct6_backwards(mapping820_hashtag_), encdec_vreg_backwards(mapping821_hashtag_), encdec_reg_backwards(mapping822_hashtag_), encdec_vreg_backwards(mapping823_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MVXMATYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__375 if {let mapping824_hashtag__var_300: BitVector<6> = v__375.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping827_hashtag__var_301: BitVector<5> = v__375.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping826_hashtag__var_302: BitVector<5> = v__375.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping825_hashtag__var_303: BitVector<5> = v__375.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping824_hashtag__var_304: BitVector<6> = v__375.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_wvxfunct6_backwards_matches(mapping824_hashtag__var_304) && (encdec_vreg_backwards_matches(mapping825_hashtag__var_303) && (encdec_reg_backwards_matches(mapping826_hashtag__var_302) && encdec_vreg_backwards_matches(mapping827_hashtag__var_301)))) && ((v__375.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__375.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping824_hashtag_: BitVector<6> = v__375.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__375.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping827_hashtag_: BitVector<5> = v__375.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping826_hashtag_: BitVector<5> = v__375.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping825_hashtag_: BitVector<5> = v__375.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping824_hashtag_: BitVector<6> = v__375.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_wvxfunct6_backwards(mapping824_hashtag_), encdec_vreg_backwards(mapping825_hashtag_), encdec_reg_backwards(mapping826_hashtag_), encdec_vreg_backwards(mapping827_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WVXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__372 if {let mapping828_hashtag__var_295: BitVector<6> = v__372.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping831_hashtag__var_296: BitVector<5> = v__372.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping830_hashtag__var_297: BitVector<5> = v__372.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping829_hashtag__var_298: BitVector<5> = v__372.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping828_hashtag__var_299: BitVector<6> = v__372.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_wxfunct6_backwards_matches(mapping828_hashtag__var_299) && (encdec_vreg_backwards_matches(mapping829_hashtag__var_298) && (encdec_reg_backwards_matches(mapping830_hashtag__var_297) && encdec_vreg_backwards_matches(mapping831_hashtag__var_296)))) && ((v__372.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__372.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping828_hashtag_: BitVector<6> = v__372.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__372.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping831_hashtag_: BitVector<5> = v__372.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping830_hashtag_: BitVector<5> = v__372.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping829_hashtag_: BitVector<5> = v__372.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping828_hashtag_: BitVector<6> = v__372.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_wxfunct6_backwards(mapping828_hashtag_), encdec_vreg_backwards(mapping829_hashtag_), encdec_reg_backwards(mapping830_hashtag_), encdec_vreg_backwards(mapping831_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__369 if {let mapping832_hashtag__var_290: BitVector<6> = v__369.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping835_hashtag__var_291: BitVector<5> = v__369.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping834_hashtag__var_292: BitVector<5> = v__369.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping833_hashtag__var_293: BitVector<5> = v__369.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping832_hashtag__var_294: BitVector<6> = v__369.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_wmvxfunct6_backwards_matches(mapping832_hashtag__var_294) && (encdec_vreg_backwards_matches(mapping833_hashtag__var_293) && (encdec_reg_backwards_matches(mapping834_hashtag__var_292) && encdec_vreg_backwards_matches(mapping835_hashtag__var_291)))) && ((v__369.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__369.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping832_hashtag_: BitVector<6> = v__369.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__369.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping835_hashtag_: BitVector<5> = v__369.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping834_hashtag_: BitVector<5> = v__369.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping833_hashtag_: BitVector<5> = v__369.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping832_hashtag_: BitVector<6> = v__369.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_wmvxfunct6_backwards(mapping832_hashtag_), encdec_vreg_backwards(mapping833_hashtag_), encdec_reg_backwards(mapping834_hashtag_), encdec_vreg_backwards(mapping835_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::WMVXTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__363 if {let mapping837_hashtag__var_288: BitVector<5> = v__363.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping836_hashtag__var_289: BitVector<5> = v__363.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping836_hashtag__var_289) && encdec_vreg_backwards_matches(mapping837_hashtag__var_288)) && ((v__363.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100000)) && ((v__363.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__363.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping837_hashtag_: BitVector<5> = v__363.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping836_hashtag_: BitVector<5> = v__363.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping836_hashtag_), encdec_vreg_backwards(mapping837_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMVSX((rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__360 if {let mapping838_hashtag__var_283: BitVector<6> = v__360.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping841_hashtag__var_284: BitVector<5> = v__360.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping840_hashtag__var_285: BitVector<5> = v__360.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping839_hashtag__var_286: BitVector<5> = v__360.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping838_hashtag__var_287: BitVector<6> = v__360.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_fvvfunct6_backwards_matches(mapping838_hashtag__var_287) && (encdec_vreg_backwards_matches(mapping839_hashtag__var_286) && (encdec_vreg_backwards_matches(mapping840_hashtag__var_285) && encdec_vreg_backwards_matches(mapping841_hashtag__var_284)))) && ((v__360.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__360.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping838_hashtag_: BitVector<6> = v__360.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__360.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping841_hashtag_: BitVector<5> = v__360.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping840_hashtag_: BitVector<5> = v__360.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping839_hashtag_: BitVector<5> = v__360.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping838_hashtag_: BitVector<6> = v__360.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_fvvfunct6_backwards(mapping838_hashtag_), encdec_vreg_backwards(mapping839_hashtag_), encdec_vreg_backwards(mapping840_hashtag_), encdec_vreg_backwards(mapping841_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__357 if {let mapping842_hashtag__var_278: BitVector<6> = v__357.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping845_hashtag__var_279: BitVector<5> = v__357.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping844_hashtag__var_280: BitVector<5> = v__357.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping843_hashtag__var_281: BitVector<5> = v__357.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping842_hashtag__var_282: BitVector<6> = v__357.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_fvvmafunct6_backwards_matches(mapping842_hashtag__var_282) && (encdec_vreg_backwards_matches(mapping843_hashtag__var_281) && (encdec_vreg_backwards_matches(mapping844_hashtag__var_280) && encdec_vreg_backwards_matches(mapping845_hashtag__var_279)))) && ((v__357.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__357.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping842_hashtag_: BitVector<6> = v__357.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__357.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping845_hashtag_: BitVector<5> = v__357.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping844_hashtag_: BitVector<5> = v__357.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping843_hashtag_: BitVector<5> = v__357.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping842_hashtag_: BitVector<6> = v__357.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_fvvmafunct6_backwards(mapping842_hashtag_), encdec_vreg_backwards(mapping843_hashtag_), encdec_vreg_backwards(mapping844_hashtag_), encdec_vreg_backwards(mapping845_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVVMATYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__354 if {let mapping846_hashtag__var_273: BitVector<6> = v__354.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping849_hashtag__var_274: BitVector<5> = v__354.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping848_hashtag__var_275: BitVector<5> = v__354.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping847_hashtag__var_276: BitVector<5> = v__354.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping846_hashtag__var_277: BitVector<6> = v__354.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_fwvvfunct6_backwards_matches(mapping846_hashtag__var_277) && (encdec_vreg_backwards_matches(mapping847_hashtag__var_276) && (encdec_vreg_backwards_matches(mapping848_hashtag__var_275) && encdec_vreg_backwards_matches(mapping849_hashtag__var_274)))) && ((v__354.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__354.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping846_hashtag_: BitVector<6> = v__354.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__354.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping849_hashtag_: BitVector<5> = v__354.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping848_hashtag_: BitVector<5> = v__354.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping847_hashtag_: BitVector<5> = v__354.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping846_hashtag_: BitVector<6> = v__354.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_fwvvfunct6_backwards(mapping846_hashtag_), encdec_vreg_backwards(mapping847_hashtag_), encdec_vreg_backwards(mapping848_hashtag_), encdec_vreg_backwards(mapping849_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__351 if {let mapping850_hashtag__var_268: BitVector<6> = v__351.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping853_hashtag__var_269: BitVector<5> = v__351.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping852_hashtag__var_270: BitVector<5> = v__351.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping851_hashtag__var_271: BitVector<5> = v__351.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping850_hashtag__var_272: BitVector<6> = v__351.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_fwvvmafunct6_backwards_matches(mapping850_hashtag__var_272) && (encdec_vreg_backwards_matches(mapping851_hashtag__var_271) && (encdec_vreg_backwards_matches(mapping852_hashtag__var_270) && encdec_vreg_backwards_matches(mapping853_hashtag__var_269)))) && ((v__351.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__351.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping850_hashtag_: BitVector<6> = v__351.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__351.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping853_hashtag_: BitVector<5> = v__351.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping852_hashtag_: BitVector<5> = v__351.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping851_hashtag_: BitVector<5> = v__351.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping850_hashtag_: BitVector<6> = v__351.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_fwvvmafunct6_backwards(mapping850_hashtag_), encdec_vreg_backwards(mapping851_hashtag_), encdec_vreg_backwards(mapping852_hashtag_), encdec_vreg_backwards(mapping853_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs1, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWVVMATYPE((funct6, vm, vs1, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__348 if {let mapping854_hashtag__var_263: BitVector<6> = v__348.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping857_hashtag__var_264: BitVector<5> = v__348.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping856_hashtag__var_265: BitVector<5> = v__348.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping855_hashtag__var_266: BitVector<5> = v__348.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping854_hashtag__var_267: BitVector<6> = v__348.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_fwvfunct6_backwards_matches(mapping854_hashtag__var_267) && (encdec_vreg_backwards_matches(mapping855_hashtag__var_266) && (encdec_vreg_backwards_matches(mapping856_hashtag__var_265) && encdec_vreg_backwards_matches(mapping857_hashtag__var_264)))) && ((v__348.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__348.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping854_hashtag_: BitVector<6> = v__348.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__348.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping857_hashtag_: BitVector<5> = v__348.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping856_hashtag_: BitVector<5> = v__348.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping855_hashtag_: BitVector<5> = v__348.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping854_hashtag_: BitVector<6> = v__348.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_fwvfunct6_backwards(mapping854_hashtag_), encdec_vreg_backwards(mapping855_hashtag_), encdec_vreg_backwards(mapping856_hashtag_), encdec_vreg_backwards(mapping857_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__344 if {let mapping860_hashtag__var_260: BitVector<5> = v__344.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping859_hashtag__var_261: BitVector<5> = v__344.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping858_hashtag__var_262: BitVector<5> = v__344.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping858_hashtag__var_262) && (encdec_vfunary0_vs1_backwards_matches(mapping859_hashtag__var_261) && encdec_vreg_backwards_matches(mapping860_hashtag__var_260))) && ((v__344.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__344.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__344.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__344.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping860_hashtag_: BitVector<5> = v__344.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping859_hashtag_: BitVector<5> = v__344.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping858_hashtag_: BitVector<5> = v__344.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping858_hashtag_), encdec_vfunary0_vs1_backwards(mapping859_hashtag_), encdec_vreg_backwards(mapping860_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vfunary0, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFUNARY0((vm, vs2, vfunary0, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__340 if {let mapping863_hashtag__var_257: BitVector<5> = v__340.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping862_hashtag__var_258: BitVector<5> = v__340.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping861_hashtag__var_259: BitVector<5> = v__340.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping861_hashtag__var_259) && (encdec_vfwunary0_vs1_backwards_matches(mapping862_hashtag__var_258) && encdec_vreg_backwards_matches(mapping863_hashtag__var_257))) && ((v__340.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__340.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__340.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__340.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping863_hashtag_: BitVector<5> = v__340.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping862_hashtag_: BitVector<5> = v__340.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping861_hashtag_: BitVector<5> = v__340.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping861_hashtag_), encdec_vfwunary0_vs1_backwards(mapping862_hashtag_), encdec_vreg_backwards(mapping863_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, vfwunary0, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFWUNARY0((vm, vs2, vfwunary0, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__336 if {let mapping866_hashtag__var_254: BitVector<5> = v__336.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping865_hashtag__var_255: BitVector<5> = v__336.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping864_hashtag__var_256: BitVector<5> = v__336.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping864_hashtag__var_256) && (encdec_vfnunary0_vs1_backwards_matches(mapping865_hashtag__var_255) && encdec_vreg_backwards_matches(mapping866_hashtag__var_254))) && ((v__336.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__336.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__336.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__336.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping866_hashtag_: BitVector<5> = v__336.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping865_hashtag_: BitVector<5> = v__336.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping864_hashtag_: BitVector<5> = v__336.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping864_hashtag_), encdec_vfnunary0_vs1_backwards(mapping865_hashtag_), encdec_vreg_backwards(mapping866_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vfnunary0, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFNUNARY0((vm, vs2, vfnunary0, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__332 if {let mapping869_hashtag__var_251: BitVector<5> = v__332.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping868_hashtag__var_252: BitVector<5> = v__332.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping867_hashtag__var_253: BitVector<5> = v__332.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping867_hashtag__var_253) && (encdec_vfunary1_vs1_backwards_matches(mapping868_hashtag__var_252) && encdec_vreg_backwards_matches(mapping869_hashtag__var_251))) && ((v__332.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010011)) && ((v__332.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__332.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__332.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping869_hashtag_: BitVector<5> = v__332.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping868_hashtag_: BitVector<5> = v__332.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping867_hashtag_: BitVector<5> = v__332.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping867_hashtag_), encdec_vfunary1_vs1_backwards(mapping868_hashtag_), encdec_vreg_backwards(mapping869_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vfunary1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFUNARY1((vm, vs2, vfunary1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__326 if {let mapping871_hashtag__var_249: BitVector<5> = v__326.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping870_hashtag__var_250: BitVector<5> = v__326.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping870_hashtag__var_250) && encdec_freg_backwards_matches(mapping871_hashtag__var_249)) && ((v__326.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0100001)) && ((v__326.subrange::<12, 20, 8>() == BitVector::<8>::new(0b00000001)) && (v__326.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping871_hashtag_: BitVector<5> = v__326.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping870_hashtag_: BitVector<5> = v__326.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping870_hashtag_), encdec_freg_backwards(mapping871_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFMVFS((vs2, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__323 if {let mapping872_hashtag__var_244: BitVector<6> = v__323.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping875_hashtag__var_245: BitVector<5> = v__323.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping874_hashtag__var_246: BitVector<5> = v__323.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping873_hashtag__var_247: BitVector<5> = v__323.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping872_hashtag__var_248: BitVector<6> = v__323.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_fvffunct6_backwards_matches(mapping872_hashtag__var_248) && (encdec_vreg_backwards_matches(mapping873_hashtag__var_247) && (encdec_freg_backwards_matches(mapping874_hashtag__var_246) && encdec_vreg_backwards_matches(mapping875_hashtag__var_245)))) && ((v__323.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__323.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping872_hashtag_: BitVector<6> = v__323.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__323.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping875_hashtag_: BitVector<5> = v__323.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping874_hashtag_: BitVector<5> = v__323.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping873_hashtag_: BitVector<5> = v__323.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping872_hashtag_: BitVector<6> = v__323.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_fvffunct6_backwards(mapping872_hashtag_), encdec_vreg_backwards(mapping873_hashtag_), encdec_freg_backwards(mapping874_hashtag_), encdec_vreg_backwards(mapping875_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVFTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__320 if {let mapping876_hashtag__var_239: BitVector<6> = v__320.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping879_hashtag__var_240: BitVector<5> = v__320.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping878_hashtag__var_241: BitVector<5> = v__320.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping877_hashtag__var_242: BitVector<5> = v__320.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping876_hashtag__var_243: BitVector<6> = v__320.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_fvfmafunct6_backwards_matches(mapping876_hashtag__var_243) && (encdec_vreg_backwards_matches(mapping877_hashtag__var_242) && (encdec_freg_backwards_matches(mapping878_hashtag__var_241) && encdec_vreg_backwards_matches(mapping879_hashtag__var_240)))) && ((v__320.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__320.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping876_hashtag_: BitVector<6> = v__320.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__320.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping879_hashtag_: BitVector<5> = v__320.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping878_hashtag_: BitVector<5> = v__320.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping877_hashtag_: BitVector<5> = v__320.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping876_hashtag_: BitVector<6> = v__320.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_fvfmafunct6_backwards(mapping876_hashtag_), encdec_vreg_backwards(mapping877_hashtag_), encdec_freg_backwards(mapping878_hashtag_), encdec_vreg_backwards(mapping879_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVFMATYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__317 if {let mapping880_hashtag__var_234: BitVector<6> = v__317.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping883_hashtag__var_235: BitVector<5> = v__317.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping882_hashtag__var_236: BitVector<5> = v__317.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping881_hashtag__var_237: BitVector<5> = v__317.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping880_hashtag__var_238: BitVector<6> = v__317.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_fwvffunct6_backwards_matches(mapping880_hashtag__var_238) && (encdec_vreg_backwards_matches(mapping881_hashtag__var_237) && (encdec_freg_backwards_matches(mapping882_hashtag__var_236) && encdec_vreg_backwards_matches(mapping883_hashtag__var_235)))) && ((v__317.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__317.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping880_hashtag_: BitVector<6> = v__317.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__317.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping883_hashtag_: BitVector<5> = v__317.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping882_hashtag_: BitVector<5> = v__317.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping881_hashtag_: BitVector<5> = v__317.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping880_hashtag_: BitVector<6> = v__317.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_fwvffunct6_backwards(mapping880_hashtag_), encdec_vreg_backwards(mapping881_hashtag_), encdec_freg_backwards(mapping882_hashtag_), encdec_vreg_backwards(mapping883_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWVFTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__314 if {let mapping884_hashtag__var_229: BitVector<6> = v__314.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping887_hashtag__var_230: BitVector<5> = v__314.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping886_hashtag__var_231: BitVector<5> = v__314.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping885_hashtag__var_232: BitVector<5> = v__314.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping884_hashtag__var_233: BitVector<6> = v__314.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_fwvfmafunct6_backwards_matches(mapping884_hashtag__var_233) && (encdec_vreg_backwards_matches(mapping885_hashtag__var_232) && (encdec_freg_backwards_matches(mapping886_hashtag__var_231) && encdec_vreg_backwards_matches(mapping887_hashtag__var_230)))) && ((v__314.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__314.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping884_hashtag_: BitVector<6> = v__314.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__314.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping887_hashtag_: BitVector<5> = v__314.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping886_hashtag_: BitVector<5> = v__314.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping885_hashtag_: BitVector<5> = v__314.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping884_hashtag_: BitVector<6> = v__314.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_fwvfmafunct6_backwards(mapping884_hashtag_), encdec_vreg_backwards(mapping885_hashtag_), encdec_freg_backwards(mapping886_hashtag_), encdec_vreg_backwards(mapping887_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWVFMATYPE((funct6, vm, rs1, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__311 if {let mapping888_hashtag__var_224: BitVector<6> = v__311.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping891_hashtag__var_225: BitVector<5> = v__311.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping890_hashtag__var_226: BitVector<5> = v__311.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping889_hashtag__var_227: BitVector<5> = v__311.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping888_hashtag__var_228: BitVector<6> = v__311.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_fwffunct6_backwards_matches(mapping888_hashtag__var_228) && (encdec_vreg_backwards_matches(mapping889_hashtag__var_227) && (encdec_freg_backwards_matches(mapping890_hashtag__var_226) && encdec_vreg_backwards_matches(mapping891_hashtag__var_225)))) && ((v__311.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__311.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping888_hashtag_: BitVector<6> = v__311.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__311.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping891_hashtag_: BitVector<5> = v__311.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping890_hashtag_: BitVector<5> = v__311.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping889_hashtag_: BitVector<5> = v__311.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping888_hashtag_: BitVector<6> = v__311.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_fwffunct6_backwards(mapping888_hashtag_), encdec_vreg_backwards(mapping889_hashtag_), encdec_freg_backwards(mapping890_hashtag_), encdec_vreg_backwards(mapping891_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FWFTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__306 if {let mapping894_hashtag__var_221: BitVector<5> = v__306.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping893_hashtag__var_222: BitVector<5> = v__306.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping892_hashtag__var_223: BitVector<5> = v__306.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping892_hashtag__var_223) && (encdec_freg_backwards_matches(mapping893_hashtag__var_222) && encdec_vreg_backwards_matches(mapping894_hashtag__var_221))) && ((v__306.subrange::<25, 32, 7>() == BitVector::<7>::new(0b0101110)) && ((v__306.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__306.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping894_hashtag_: BitVector<5> = v__306.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping893_hashtag_: BitVector<5> = v__306.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping892_hashtag_: BitVector<5> = v__306.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping892_hashtag_), encdec_freg_backwards(mapping893_hashtag_), encdec_vreg_backwards(mapping894_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFMERGE((vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__300 if {let mapping896_hashtag__var_219: BitVector<5> = v__300.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping895_hashtag__var_220: BitVector<5> = v__300.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_freg_backwards_matches(mapping895_hashtag__var_220) && encdec_vreg_backwards_matches(mapping896_hashtag__var_219)) && ((v__300.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010111100000)) && ((v__300.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__300.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping896_hashtag_: BitVector<5> = v__300.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping895_hashtag_: BitVector<5> = v__300.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_freg_backwards(mapping895_hashtag_), encdec_vreg_backwards(mapping896_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFMV((rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__294 if {let mapping898_hashtag__var_217: BitVector<5> = v__294.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping897_hashtag__var_218: BitVector<5> = v__294.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_freg_backwards_matches(mapping897_hashtag__var_218) && encdec_vreg_backwards_matches(mapping898_hashtag__var_217)) && ((v__294.subrange::<20, 32, 12>() == BitVector::<12>::new(0b010000100000)) && ((v__294.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__294.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping898_hashtag_: BitVector<5> = v__294.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping897_hashtag_: BitVector<5> = v__294.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_freg_backwards(mapping897_hashtag_), encdec_vreg_backwards(mapping898_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFMVSF((rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__289 if {let mapping901_hashtag__var_214: BitVector<5> = v__289.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping900_hashtag__var_215: BitVector<3> = v__289.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping899_hashtag__var_216: BitVector<5> = v__289.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping899_hashtag__var_216) && (encdec_vlewidth_backwards_matches(mapping900_hashtag__var_215) && encdec_vreg_backwards_matches(mapping901_hashtag__var_214))) && ((v__289.subrange::<26, 29, 3>() == BitVector::<3>::new(0b000)) && ((v__289.subrange::<20, 25, 5>() == BitVector::<5>::new(0b00000)) && (v__289.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111)))))} => {let nf: BitVector<3> = v__289.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__289.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let nf: BitVector<3> = v__289.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping901_hashtag_: BitVector<5> = v__289.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping900_hashtag_: BitVector<3> = v__289.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping899_hashtag_: BitVector<5> = v__289.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping899_hashtag_), encdec_vlewidth_backwards(mapping900_hashtag_), encdec_vreg_backwards(mapping901_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLSEGTYPE((nf, vm, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__284 if {let mapping904_hashtag__var_211: BitVector<5> = v__284.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping903_hashtag__var_212: BitVector<3> = v__284.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping902_hashtag__var_213: BitVector<5> = v__284.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping902_hashtag__var_213) && (encdec_vlewidth_backwards_matches(mapping903_hashtag__var_212) && encdec_vreg_backwards_matches(mapping904_hashtag__var_211))) && ((v__284.subrange::<26, 29, 3>() == BitVector::<3>::new(0b000)) && ((v__284.subrange::<20, 25, 5>() == BitVector::<5>::new(0b10000)) && (v__284.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111)))))} => {let nf: BitVector<3> = v__284.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__284.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let nf: BitVector<3> = v__284.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping904_hashtag_: BitVector<5> = v__284.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping903_hashtag_: BitVector<3> = v__284.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping902_hashtag_: BitVector<5> = v__284.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping902_hashtag_), encdec_vlewidth_backwards(mapping903_hashtag_), encdec_vreg_backwards(mapping904_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLSEGFFTYPE((nf, vm, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__279 if {let mapping907_hashtag__var_208: BitVector<5> = v__279.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping906_hashtag__var_209: BitVector<3> = v__279.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping905_hashtag__var_210: BitVector<5> = v__279.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping905_hashtag__var_210) && (encdec_vlewidth_backwards_matches(mapping906_hashtag__var_209) && encdec_vreg_backwards_matches(mapping907_hashtag__var_208))) && ((v__279.subrange::<26, 29, 3>() == BitVector::<3>::new(0b000)) && ((v__279.subrange::<20, 25, 5>() == BitVector::<5>::new(0b00000)) && (v__279.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111)))))} => {let nf: BitVector<3> = v__279.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__279.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let nf: BitVector<3> = v__279.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping907_hashtag_: BitVector<5> = v__279.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping906_hashtag_: BitVector<3> = v__279.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping905_hashtag_: BitVector<5> = v__279.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping905_hashtag_), encdec_vlewidth_backwards(mapping906_hashtag_), encdec_vreg_backwards(mapping907_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, width, vs3) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSSEGTYPE((nf, vm, rs1, width, vs3)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__275 if {let mapping911_hashtag__var_204: BitVector<5> = v__275.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping910_hashtag__var_205: BitVector<3> = v__275.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping909_hashtag__var_206: BitVector<5> = v__275.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping908_hashtag__var_207: BitVector<5> = v__275.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping908_hashtag__var_207) && (encdec_reg_backwards_matches(mapping909_hashtag__var_206) && (encdec_vlewidth_backwards_matches(mapping910_hashtag__var_205) && encdec_vreg_backwards_matches(mapping911_hashtag__var_204)))) && ((v__275.subrange::<26, 29, 3>() == BitVector::<3>::new(0b010)) && (v__275.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let nf: BitVector<3> = v__275.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__275.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let nf: BitVector<3> = v__275.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping911_hashtag_: BitVector<5> = v__275.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping910_hashtag_: BitVector<3> = v__275.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping909_hashtag_: BitVector<5> = v__275.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping908_hashtag_: BitVector<5> = v__275.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping908_hashtag_), encdec_reg_backwards(mapping909_hashtag_), encdec_vlewidth_backwards(mapping910_hashtag_), encdec_vreg_backwards(mapping911_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs2, rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLSSEGTYPE((nf, vm, rs2, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__271 if {let mapping915_hashtag__var_200: BitVector<5> = v__271.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping914_hashtag__var_201: BitVector<3> = v__271.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping913_hashtag__var_202: BitVector<5> = v__271.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping912_hashtag__var_203: BitVector<5> = v__271.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping912_hashtag__var_203) && (encdec_reg_backwards_matches(mapping913_hashtag__var_202) && (encdec_vlewidth_backwards_matches(mapping914_hashtag__var_201) && encdec_vreg_backwards_matches(mapping915_hashtag__var_200)))) && ((v__271.subrange::<26, 29, 3>() == BitVector::<3>::new(0b010)) && (v__271.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let nf: BitVector<3> = v__271.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__271.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let nf: BitVector<3> = v__271.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping915_hashtag_: BitVector<5> = v__271.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping914_hashtag_: BitVector<3> = v__271.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping913_hashtag_: BitVector<5> = v__271.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping912_hashtag_: BitVector<5> = v__271.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping912_hashtag_), encdec_reg_backwards(mapping913_hashtag_), encdec_vlewidth_backwards(mapping914_hashtag_), encdec_vreg_backwards(mapping915_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, width, vs3) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSSSEGTYPE((nf, vm, rs2, rs1, width, vs3)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__267 if {let mapping919_hashtag__var_196: BitVector<5> = v__267.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping918_hashtag__var_197: BitVector<3> = v__267.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping917_hashtag__var_198: BitVector<5> = v__267.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping916_hashtag__var_199: BitVector<5> = v__267.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping916_hashtag__var_199) && (encdec_reg_backwards_matches(mapping917_hashtag__var_198) && (encdec_vlewidth_backwards_matches(mapping918_hashtag__var_197) && encdec_vreg_backwards_matches(mapping919_hashtag__var_196)))) && ((v__267.subrange::<26, 29, 3>() == BitVector::<3>::new(0b001)) && (v__267.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let nf: BitVector<3> = v__267.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__267.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let nf: BitVector<3> = v__267.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping919_hashtag_: BitVector<5> = v__267.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping918_hashtag_: BitVector<3> = v__267.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping917_hashtag_: BitVector<5> = v__267.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping916_hashtag_: BitVector<5> = v__267.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping916_hashtag_), encdec_reg_backwards(mapping917_hashtag_), encdec_vlewidth_backwards(mapping918_hashtag_), encdec_vreg_backwards(mapping919_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLUXSEGTYPE((nf, vm, vs2, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__263 if {let mapping923_hashtag__var_192: BitVector<5> = v__263.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping922_hashtag__var_193: BitVector<3> = v__263.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping921_hashtag__var_194: BitVector<5> = v__263.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping920_hashtag__var_195: BitVector<5> = v__263.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping920_hashtag__var_195) && (encdec_reg_backwards_matches(mapping921_hashtag__var_194) && (encdec_vlewidth_backwards_matches(mapping922_hashtag__var_193) && encdec_vreg_backwards_matches(mapping923_hashtag__var_192)))) && ((v__263.subrange::<26, 29, 3>() == BitVector::<3>::new(0b011)) && (v__263.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let nf: BitVector<3> = v__263.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__263.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let nf: BitVector<3> = v__263.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping923_hashtag_: BitVector<5> = v__263.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping922_hashtag_: BitVector<3> = v__263.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping921_hashtag_: BitVector<5> = v__263.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping920_hashtag_: BitVector<5> = v__263.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping920_hashtag_), encdec_reg_backwards(mapping921_hashtag_), encdec_vlewidth_backwards(mapping922_hashtag_), encdec_vreg_backwards(mapping923_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLOXSEGTYPE((nf, vm, vs2, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__259 if {let mapping927_hashtag__var_188: BitVector<5> = v__259.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping926_hashtag__var_189: BitVector<3> = v__259.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping925_hashtag__var_190: BitVector<5> = v__259.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping924_hashtag__var_191: BitVector<5> = v__259.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping924_hashtag__var_191) && (encdec_reg_backwards_matches(mapping925_hashtag__var_190) && (encdec_vlewidth_backwards_matches(mapping926_hashtag__var_189) && encdec_vreg_backwards_matches(mapping927_hashtag__var_188)))) && ((v__259.subrange::<26, 29, 3>() == BitVector::<3>::new(0b001)) && (v__259.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let nf: BitVector<3> = v__259.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__259.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let nf: BitVector<3> = v__259.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping927_hashtag_: BitVector<5> = v__259.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping926_hashtag_: BitVector<3> = v__259.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping925_hashtag_: BitVector<5> = v__259.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping924_hashtag_: BitVector<5> = v__259.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping924_hashtag_), encdec_reg_backwards(mapping925_hashtag_), encdec_vlewidth_backwards(mapping926_hashtag_), encdec_vreg_backwards(mapping927_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, rs1, width, vs3) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSUXSEGTYPE((nf, vm, vs2, rs1, width, vs3)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__255 if {let mapping931_hashtag__var_184: BitVector<5> = v__255.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping930_hashtag__var_185: BitVector<3> = v__255.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping929_hashtag__var_186: BitVector<5> = v__255.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping928_hashtag__var_187: BitVector<5> = v__255.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping928_hashtag__var_187) && (encdec_reg_backwards_matches(mapping929_hashtag__var_186) && (encdec_vlewidth_backwards_matches(mapping930_hashtag__var_185) && encdec_vreg_backwards_matches(mapping931_hashtag__var_184)))) && ((v__255.subrange::<26, 29, 3>() == BitVector::<3>::new(0b011)) && (v__255.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111))))} => {let nf: BitVector<3> = v__255.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__255.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let nf: BitVector<3> = v__255.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping931_hashtag_: BitVector<5> = v__255.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping930_hashtag_: BitVector<3> = v__255.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping929_hashtag_: BitVector<5> = v__255.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping928_hashtag_: BitVector<5> = v__255.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping928_hashtag_), encdec_reg_backwards(mapping929_hashtag_), encdec_vlewidth_backwards(mapping930_hashtag_), encdec_vreg_backwards(mapping931_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, rs1, width, vs3) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSOXSEGTYPE((nf, vm, vs2, rs1, width, vs3)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__249 if {let mapping934_hashtag__var_181: BitVector<5> = v__249.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping933_hashtag__var_182: BitVector<3> = v__249.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping932_hashtag__var_183: BitVector<5> = v__249.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_reg_backwards_matches(mapping932_hashtag__var_183) && (encdec_vlewidth_backwards_matches(mapping933_hashtag__var_182) && encdec_vreg_backwards_matches(mapping934_hashtag__var_181))) && ((v__249.subrange::<20, 29, 9>() == BitVector::<9>::new(0b000101000)) && (v__249.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0000111))))} => {let nf: BitVector<3> = v__249.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let nf: BitVector<3> = v__249.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping934_hashtag_: BitVector<5> = v__249.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping933_hashtag_: BitVector<3> = v__249.subrange::<12, 15, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping932_hashtag_: BitVector<5> = v__249.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_reg_backwards(mapping932_hashtag_), encdec_vlewidth_backwards(mapping933_hashtag_), encdec_vreg_backwards(mapping934_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (rs1, width, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VLRETYPE((nf, rs1, width, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__242 if {let mapping936_hashtag__var_179: BitVector<5> = v__242.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping935_hashtag__var_180: BitVector<5> = v__242.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_reg_backwards_matches(mapping935_hashtag__var_180) && encdec_vreg_backwards_matches(mapping936_hashtag__var_179)) && ((v__242.subrange::<20, 29, 9>() == BitVector::<9>::new(0b000101000)) && ((v__242.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__242.subrange::<0, 7, 7>() == BitVector::<7>::new(0b0100111)))))} => {let nf: BitVector<3> = v__242.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let nf: BitVector<3> = v__242.subrange::<29, 32, 3>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping936_hashtag_: BitVector<5> = v__242.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping935_hashtag_: BitVector<5> = v__242.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_reg_backwards(mapping935_hashtag_), encdec_vreg_backwards(mapping936_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (rs1, vs3) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VSRETYPE((nf, rs1, vs3)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__235 if {let mapping939_hashtag__var_176: BitVector<7> = v__235.subrange::<0, 7, 7>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping938_hashtag__var_177: BitVector<5> = v__235.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping937_hashtag__var_178: BitVector<5> = v__235.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping937_hashtag__var_178) && (encdec_vreg_backwards_matches(mapping938_hashtag__var_177) && encdec_lsop_backwards_matches(mapping939_hashtag__var_176))) && ((v__235.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000000101011)) && (v__235.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000))))} => {let mapping939_hashtag_: BitVector<7> = v__235.subrange::<0, 7, 7>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping938_hashtag_: BitVector<5> = v__235.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping937_hashtag_: BitVector<5> = v__235.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping937_hashtag_), encdec_vreg_backwards(mapping938_hashtag_), encdec_lsop_backwards(mapping939_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, vd_or_vs3, op) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMTYPE((rs1, vd_or_vs3, op)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__231 if {let mapping940_hashtag__var_171: BitVector<6> = v__231.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping943_hashtag__var_172: BitVector<5> = v__231.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping942_hashtag__var_173: BitVector<5> = v__231.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping941_hashtag__var_174: BitVector<5> = v__231.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping940_hashtag__var_175: BitVector<6> = v__231.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_mmfunct6_backwards_matches(mapping940_hashtag__var_175) && (encdec_vreg_backwards_matches(mapping941_hashtag__var_174) && (encdec_vreg_backwards_matches(mapping942_hashtag__var_173) && encdec_vreg_backwards_matches(mapping943_hashtag__var_172)))) && ((v__231.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__231.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__231.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping940_hashtag_: BitVector<6> = v__231.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping943_hashtag_: BitVector<5> = v__231.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping942_hashtag_: BitVector<5> = v__231.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping941_hashtag_: BitVector<5> = v__231.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping940_hashtag_: BitVector<6> = v__231.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_mmfunct6_backwards(mapping940_hashtag_), encdec_vreg_backwards(mapping941_hashtag_), encdec_vreg_backwards(mapping942_hashtag_), encdec_vreg_backwards(mapping943_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::MMTYPE((funct6, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__226 if {let mapping945_hashtag__var_169: BitVector<5> = v__226.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping944_hashtag__var_170: BitVector<5> = v__226.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping944_hashtag__var_170) && encdec_reg_backwards_matches(mapping945_hashtag__var_169)) && ((v__226.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010000)) && ((v__226.subrange::<12, 20, 8>() == BitVector::<8>::new(0b10000010)) && (v__226.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__226.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping945_hashtag_: BitVector<5> = v__226.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping944_hashtag_: BitVector<5> = v__226.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping944_hashtag_), encdec_reg_backwards(mapping945_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VCPOP_M((vm, vs2, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__221 if {let mapping947_hashtag__var_167: BitVector<5> = v__221.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping946_hashtag__var_168: BitVector<5> = v__221.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping946_hashtag__var_168) && encdec_reg_backwards_matches(mapping947_hashtag__var_167)) && ((v__221.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010000)) && ((v__221.subrange::<12, 20, 8>() == BitVector::<8>::new(0b10001010)) && (v__221.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__221.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping947_hashtag_: BitVector<5> = v__221.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping946_hashtag_: BitVector<5> = v__221.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping946_hashtag_), encdec_reg_backwards(mapping947_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, rd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VFIRST_M((vm, vs2, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__216 if {let mapping949_hashtag__var_165: BitVector<5> = v__216.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping948_hashtag__var_166: BitVector<5> = v__216.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping948_hashtag__var_166) && encdec_vreg_backwards_matches(mapping949_hashtag__var_165)) && ((v__216.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__216.subrange::<12, 20, 8>() == BitVector::<8>::new(0b00001010)) && (v__216.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__216.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping949_hashtag_: BitVector<5> = v__216.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping948_hashtag_: BitVector<5> = v__216.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping948_hashtag_), encdec_vreg_backwards(mapping949_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMSBF_M((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__211 if {let mapping951_hashtag__var_163: BitVector<5> = v__211.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping950_hashtag__var_164: BitVector<5> = v__211.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping950_hashtag__var_164) && encdec_vreg_backwards_matches(mapping951_hashtag__var_163)) && ((v__211.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__211.subrange::<12, 20, 8>() == BitVector::<8>::new(0b00011010)) && (v__211.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__211.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping951_hashtag_: BitVector<5> = v__211.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping950_hashtag_: BitVector<5> = v__211.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping950_hashtag_), encdec_vreg_backwards(mapping951_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMSIF_M((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__206 if {let mapping953_hashtag__var_161: BitVector<5> = v__206.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping952_hashtag__var_162: BitVector<5> = v__206.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping952_hashtag__var_162) && encdec_vreg_backwards_matches(mapping953_hashtag__var_161)) && ((v__206.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__206.subrange::<12, 20, 8>() == BitVector::<8>::new(0b00010010)) && (v__206.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__206.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping953_hashtag_: BitVector<5> = v__206.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping952_hashtag_: BitVector<5> = v__206.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping952_hashtag_), encdec_vreg_backwards(mapping953_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VMSOF_M((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__201 if {let mapping955_hashtag__var_159: BitVector<5> = v__201.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping954_hashtag__var_160: BitVector<5> = v__201.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping954_hashtag__var_160) && encdec_vreg_backwards_matches(mapping955_hashtag__var_159)) && ((v__201.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__201.subrange::<12, 20, 8>() == BitVector::<8>::new(0b10000010)) && (v__201.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__201.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping955_hashtag_: BitVector<5> = v__201.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping954_hashtag_: BitVector<5> = v__201.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping954_hashtag_), encdec_vreg_backwards(mapping955_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VIOTA_M((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__195 if {let mapping956_hashtag__var_158: BitVector<5> = v__195.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (encdec_vreg_backwards_matches(mapping956_hashtag__var_158) && ((v__195.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__195.subrange::<12, 25, 13>() == BitVector::<13>::new(0b0000010001010)) && (v__195.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__195.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping956_hashtag_: BitVector<5> = v__195.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match encdec_vreg_backwards(mapping956_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    vd if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VID_V((vm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__191 if {let mapping957_hashtag__var_153: BitVector<6> = v__191.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping960_hashtag__var_154: BitVector<5> = v__191.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping959_hashtag__var_155: BitVector<5> = v__191.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping958_hashtag__var_156: BitVector<5> = v__191.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping957_hashtag__var_157: BitVector<6> = v__191.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vvmfunct6_backwards_matches(mapping957_hashtag__var_157) && (encdec_vreg_backwards_matches(mapping958_hashtag__var_156) && (encdec_vreg_backwards_matches(mapping959_hashtag__var_155) && encdec_vreg_backwards_matches(mapping960_hashtag__var_154)))) && ((v__191.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__191.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__191.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping957_hashtag_: BitVector<6> = v__191.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping960_hashtag_: BitVector<5> = v__191.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping959_hashtag_: BitVector<5> = v__191.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping958_hashtag_: BitVector<5> = v__191.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping957_hashtag_: BitVector<6> = v__191.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vvmfunct6_backwards(mapping957_hashtag_), encdec_vreg_backwards(mapping958_hashtag_), encdec_vreg_backwards(mapping959_hashtag_), encdec_vreg_backwards(mapping960_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VVMTYPE((funct6, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__187 if {let mapping961_hashtag__var_148: BitVector<6> = v__187.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping964_hashtag__var_149: BitVector<5> = v__187.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping963_hashtag__var_150: BitVector<5> = v__187.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping962_hashtag__var_151: BitVector<5> = v__187.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping961_hashtag__var_152: BitVector<6> = v__187.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vvmcfunct6_backwards_matches(mapping961_hashtag__var_152) && (encdec_vreg_backwards_matches(mapping962_hashtag__var_151) && (encdec_vreg_backwards_matches(mapping963_hashtag__var_150) && encdec_vreg_backwards_matches(mapping964_hashtag__var_149)))) && ((v__187.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__187.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__187.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping961_hashtag_: BitVector<6> = v__187.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping964_hashtag_: BitVector<5> = v__187.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping963_hashtag_: BitVector<5> = v__187.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping962_hashtag_: BitVector<5> = v__187.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping961_hashtag_: BitVector<6> = v__187.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vvmcfunct6_backwards(mapping961_hashtag_), encdec_vreg_backwards(mapping962_hashtag_), encdec_vreg_backwards(mapping963_hashtag_), encdec_vreg_backwards(mapping964_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VVMCTYPE((funct6, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__183 if {let mapping965_hashtag__var_143: BitVector<6> = v__183.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping968_hashtag__var_144: BitVector<5> = v__183.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping967_hashtag__var_145: BitVector<5> = v__183.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping966_hashtag__var_146: BitVector<5> = v__183.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping965_hashtag__var_147: BitVector<6> = v__183.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vvmsfunct6_backwards_matches(mapping965_hashtag__var_147) && (encdec_vreg_backwards_matches(mapping966_hashtag__var_146) && (encdec_vreg_backwards_matches(mapping967_hashtag__var_145) && encdec_vreg_backwards_matches(mapping968_hashtag__var_144)))) && ((v__183.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__183.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__183.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping965_hashtag_: BitVector<6> = v__183.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping968_hashtag_: BitVector<5> = v__183.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping967_hashtag_: BitVector<5> = v__183.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping966_hashtag_: BitVector<5> = v__183.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping965_hashtag_: BitVector<6> = v__183.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vvmsfunct6_backwards(mapping965_hashtag_), encdec_vreg_backwards(mapping966_hashtag_), encdec_vreg_backwards(mapping967_hashtag_), encdec_vreg_backwards(mapping968_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VVMSTYPE((funct6, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__180 if {let mapping969_hashtag__var_138: BitVector<6> = v__180.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping972_hashtag__var_139: BitVector<5> = v__180.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping971_hashtag__var_140: BitVector<5> = v__180.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping970_hashtag__var_141: BitVector<5> = v__180.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping969_hashtag__var_142: BitVector<6> = v__180.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vvcmpfunct6_backwards_matches(mapping969_hashtag__var_142) && (encdec_vreg_backwards_matches(mapping970_hashtag__var_141) && (encdec_vreg_backwards_matches(mapping971_hashtag__var_140) && encdec_vreg_backwards_matches(mapping972_hashtag__var_139)))) && ((v__180.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__180.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping969_hashtag_: BitVector<6> = v__180.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__180.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping972_hashtag_: BitVector<5> = v__180.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping971_hashtag_: BitVector<5> = v__180.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping970_hashtag_: BitVector<5> = v__180.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping969_hashtag_: BitVector<6> = v__180.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vvcmpfunct6_backwards(mapping969_hashtag_), encdec_vreg_backwards(mapping970_hashtag_), encdec_vreg_backwards(mapping971_hashtag_), encdec_vreg_backwards(mapping972_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VVCMPTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__176 if {let mapping973_hashtag__var_133: BitVector<6> = v__176.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping976_hashtag__var_134: BitVector<5> = v__176.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping975_hashtag__var_135: BitVector<5> = v__176.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping974_hashtag__var_136: BitVector<5> = v__176.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping973_hashtag__var_137: BitVector<6> = v__176.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vxmfunct6_backwards_matches(mapping973_hashtag__var_137) && (encdec_vreg_backwards_matches(mapping974_hashtag__var_136) && (encdec_reg_backwards_matches(mapping975_hashtag__var_135) && encdec_vreg_backwards_matches(mapping976_hashtag__var_134)))) && ((v__176.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__176.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__176.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping973_hashtag_: BitVector<6> = v__176.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping976_hashtag_: BitVector<5> = v__176.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping975_hashtag_: BitVector<5> = v__176.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping974_hashtag_: BitVector<5> = v__176.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping973_hashtag_: BitVector<6> = v__176.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vxmfunct6_backwards(mapping973_hashtag_), encdec_vreg_backwards(mapping974_hashtag_), encdec_reg_backwards(mapping975_hashtag_), encdec_vreg_backwards(mapping976_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXMTYPE((funct6, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__172 if {let mapping977_hashtag__var_128: BitVector<6> = v__172.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping980_hashtag__var_129: BitVector<5> = v__172.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping979_hashtag__var_130: BitVector<5> = v__172.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping978_hashtag__var_131: BitVector<5> = v__172.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping977_hashtag__var_132: BitVector<6> = v__172.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vxmcfunct6_backwards_matches(mapping977_hashtag__var_132) && (encdec_vreg_backwards_matches(mapping978_hashtag__var_131) && (encdec_reg_backwards_matches(mapping979_hashtag__var_130) && encdec_vreg_backwards_matches(mapping980_hashtag__var_129)))) && ((v__172.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__172.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__172.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping977_hashtag_: BitVector<6> = v__172.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping980_hashtag_: BitVector<5> = v__172.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping979_hashtag_: BitVector<5> = v__172.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping978_hashtag_: BitVector<5> = v__172.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping977_hashtag_: BitVector<6> = v__172.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vxmcfunct6_backwards(mapping977_hashtag_), encdec_vreg_backwards(mapping978_hashtag_), encdec_reg_backwards(mapping979_hashtag_), encdec_vreg_backwards(mapping980_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXMCTYPE((funct6, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__168 if {let mapping981_hashtag__var_123: BitVector<6> = v__168.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping984_hashtag__var_124: BitVector<5> = v__168.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping983_hashtag__var_125: BitVector<5> = v__168.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping982_hashtag__var_126: BitVector<5> = v__168.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping981_hashtag__var_127: BitVector<6> = v__168.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vxmsfunct6_backwards_matches(mapping981_hashtag__var_127) && (encdec_vreg_backwards_matches(mapping982_hashtag__var_126) && (encdec_reg_backwards_matches(mapping983_hashtag__var_125) && encdec_vreg_backwards_matches(mapping984_hashtag__var_124)))) && ((v__168.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__168.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__168.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping981_hashtag_: BitVector<6> = v__168.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping984_hashtag_: BitVector<5> = v__168.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping983_hashtag_: BitVector<5> = v__168.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping982_hashtag_: BitVector<5> = v__168.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping981_hashtag_: BitVector<6> = v__168.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vxmsfunct6_backwards(mapping981_hashtag_), encdec_vreg_backwards(mapping982_hashtag_), encdec_reg_backwards(mapping983_hashtag_), encdec_vreg_backwards(mapping984_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXMSTYPE((funct6, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__165 if {let mapping985_hashtag__var_118: BitVector<6> = v__165.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping988_hashtag__var_119: BitVector<5> = v__165.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping987_hashtag__var_120: BitVector<5> = v__165.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping986_hashtag__var_121: BitVector<5> = v__165.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping985_hashtag__var_122: BitVector<6> = v__165.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vxcmpfunct6_backwards_matches(mapping985_hashtag__var_122) && (encdec_vreg_backwards_matches(mapping986_hashtag__var_121) && (encdec_reg_backwards_matches(mapping987_hashtag__var_120) && encdec_vreg_backwards_matches(mapping988_hashtag__var_119)))) && ((v__165.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__165.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping985_hashtag_: BitVector<6> = v__165.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__165.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping988_hashtag_: BitVector<5> = v__165.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping987_hashtag_: BitVector<5> = v__165.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping986_hashtag_: BitVector<5> = v__165.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping985_hashtag_: BitVector<6> = v__165.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vxcmpfunct6_backwards(mapping985_hashtag_), encdec_vreg_backwards(mapping986_hashtag_), encdec_reg_backwards(mapping987_hashtag_), encdec_vreg_backwards(mapping988_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VXCMPTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__161 if {let mapping989_hashtag__var_114: BitVector<6> = v__161.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping991_hashtag__var_115: BitVector<5> = v__161.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping990_hashtag__var_116: BitVector<5> = v__161.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping989_hashtag__var_117: BitVector<6> = v__161.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vimfunct6_backwards_matches(mapping989_hashtag__var_117) && (encdec_vreg_backwards_matches(mapping990_hashtag__var_116) && encdec_vreg_backwards_matches(mapping991_hashtag__var_115))) && ((v__161.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__161.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__161.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping989_hashtag_: BitVector<6> = v__161.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let simm: BitVector<5> = v__161.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping991_hashtag_: BitVector<5> = v__161.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping990_hashtag_: BitVector<5> = v__161.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping989_hashtag_: BitVector<6> = v__161.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vimfunct6_backwards(mapping989_hashtag_), encdec_vreg_backwards(mapping990_hashtag_), encdec_vreg_backwards(mapping991_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VIMTYPE((funct6, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__157 if {let mapping992_hashtag__var_110: BitVector<6> = v__157.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping994_hashtag__var_111: BitVector<5> = v__157.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping993_hashtag__var_112: BitVector<5> = v__157.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping992_hashtag__var_113: BitVector<6> = v__157.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vimcfunct6_backwards_matches(mapping992_hashtag__var_113) && (encdec_vreg_backwards_matches(mapping993_hashtag__var_112) && encdec_vreg_backwards_matches(mapping994_hashtag__var_111))) && ((v__157.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__157.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__157.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping992_hashtag_: BitVector<6> = v__157.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let simm: BitVector<5> = v__157.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping994_hashtag_: BitVector<5> = v__157.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping993_hashtag_: BitVector<5> = v__157.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping992_hashtag_: BitVector<6> = v__157.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vimcfunct6_backwards(mapping992_hashtag_), encdec_vreg_backwards(mapping993_hashtag_), encdec_vreg_backwards(mapping994_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VIMCTYPE((funct6, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__153 if {let mapping995_hashtag__var_106: BitVector<6> = v__153.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping997_hashtag__var_107: BitVector<5> = v__153.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping996_hashtag__var_108: BitVector<5> = v__153.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping995_hashtag__var_109: BitVector<6> = v__153.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vimsfunct6_backwards_matches(mapping995_hashtag__var_109) && (encdec_vreg_backwards_matches(mapping996_hashtag__var_108) && encdec_vreg_backwards_matches(mapping997_hashtag__var_107))) && ((v__153.subrange::<25, 26, 1>() == BitVector::<1>::new(0b0)) && ((v__153.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__153.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let mapping995_hashtag_: BitVector<6> = v__153.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let simm: BitVector<5> = v__153.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping997_hashtag_: BitVector<5> = v__153.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping996_hashtag_: BitVector<5> = v__153.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping995_hashtag_: BitVector<6> = v__153.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vimsfunct6_backwards(mapping995_hashtag_), encdec_vreg_backwards(mapping996_hashtag_), encdec_vreg_backwards(mapping997_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VIMSTYPE((funct6, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__150 if {let mapping998_hashtag__var_102: BitVector<6> = v__150.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping999_hashtag__var_103: BitVector<5> = v__150.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping998_hashtag__var_104: BitVector<6> = v__150.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1000_hashtag__var_105: BitVector<5> = v__150.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vicmpfunct6_backwards_matches(mapping998_hashtag__var_104) && (encdec_vreg_backwards_matches(mapping999_hashtag__var_103) && encdec_vreg_backwards_matches(mapping1000_hashtag__var_105))) && ((v__150.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__150.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping998_hashtag_: BitVector<6> = v__150.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__150.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let simm: BitVector<5> = v__150.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping999_hashtag_: BitVector<5> = v__150.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping998_hashtag_: BitVector<6> = v__150.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1000_hashtag_: BitVector<5> = v__150.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vicmpfunct6_backwards(mapping998_hashtag_), encdec_vreg_backwards(mapping999_hashtag_), encdec_vreg_backwards(mapping1000_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::VICMPTYPE((funct6, vm, vs2, simm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__147 if {let mapping1001_hashtag__var_97: BitVector<6> = v__147.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1004_hashtag__var_98: BitVector<5> = v__147.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1003_hashtag__var_99: BitVector<5> = v__147.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1002_hashtag__var_100: BitVector<5> = v__147.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1001_hashtag__var_101: BitVector<6> = v__147.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_fvvmfunct6_backwards_matches(mapping1001_hashtag__var_101) && (encdec_vreg_backwards_matches(mapping1002_hashtag__var_100) && (encdec_vreg_backwards_matches(mapping1003_hashtag__var_99) && encdec_vreg_backwards_matches(mapping1004_hashtag__var_98)))) && ((v__147.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__147.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping1001_hashtag_: BitVector<6> = v__147.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__147.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1004_hashtag_: BitVector<5> = v__147.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1003_hashtag_: BitVector<5> = v__147.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1002_hashtag_: BitVector<5> = v__147.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1001_hashtag_: BitVector<6> = v__147.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_fvvmfunct6_backwards(mapping1001_hashtag_), encdec_vreg_backwards(mapping1002_hashtag_), encdec_vreg_backwards(mapping1003_hashtag_), encdec_vreg_backwards(mapping1004_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVVMTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__144 if {let mapping1005_hashtag__var_92: BitVector<6> = v__144.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1008_hashtag__var_93: BitVector<5> = v__144.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1007_hashtag__var_94: BitVector<5> = v__144.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1006_hashtag__var_95: BitVector<5> = v__144.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1005_hashtag__var_96: BitVector<6> = v__144.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_fvfmfunct6_backwards_matches(mapping1005_hashtag__var_96) && (encdec_vreg_backwards_matches(mapping1006_hashtag__var_95) && (encdec_freg_backwards_matches(mapping1007_hashtag__var_94) && encdec_vreg_backwards_matches(mapping1008_hashtag__var_93)))) && ((v__144.subrange::<12, 15, 3>() == BitVector::<3>::new(0b101)) && (v__144.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping1005_hashtag_: BitVector<6> = v__144.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let vm: BitVector<1> = v__144.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1008_hashtag_: BitVector<5> = v__144.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1007_hashtag_: BitVector<5> = v__144.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1006_hashtag_: BitVector<5> = v__144.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1005_hashtag_: BitVector<6> = v__144.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_fvfmfunct6_backwards(mapping1005_hashtag_), encdec_vreg_backwards(mapping1006_hashtag_), encdec_freg_backwards(mapping1007_hashtag_), encdec_vreg_backwards(mapping1008_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (funct6, vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::FVFMTYPE((funct6, vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__141 if {let mapping1009_hashtag__var_87: BitVector<6> = v__141.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1012_hashtag__var_88: BitVector<5> = v__141.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1011_hashtag__var_89: BitVector<5> = v__141.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1010_hashtag__var_90: BitVector<5> = v__141.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1009_hashtag__var_91: BitVector<6> = v__141.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_rivvfunct6_backwards_matches(mapping1009_hashtag__var_91) && (encdec_vreg_backwards_matches(mapping1010_hashtag__var_90) && (encdec_vreg_backwards_matches(mapping1011_hashtag__var_89) && encdec_vreg_backwards_matches(mapping1012_hashtag__var_88)))) && ((v__141.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__141.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping1009_hashtag_: BitVector<6> = v__141.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let vm: BitVector<1> = v__141.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1012_hashtag_: BitVector<5> = v__141.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1011_hashtag_: BitVector<5> = v__141.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1010_hashtag_: BitVector<5> = v__141.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1009_hashtag_: BitVector<6> = v__141.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_rivvfunct6_backwards(mapping1009_hashtag_), encdec_vreg_backwards(mapping1010_hashtag_), encdec_vreg_backwards(mapping1011_hashtag_), encdec_vreg_backwards(mapping1012_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::RIVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__138 if {let mapping1013_hashtag__var_82: BitVector<6> = v__138.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1016_hashtag__var_83: BitVector<5> = v__138.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1015_hashtag__var_84: BitVector<5> = v__138.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1014_hashtag__var_85: BitVector<5> = v__138.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1013_hashtag__var_86: BitVector<6> = v__138.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_rmvvfunct6_backwards_matches(mapping1013_hashtag__var_86) && (encdec_vreg_backwards_matches(mapping1014_hashtag__var_85) && (encdec_vreg_backwards_matches(mapping1015_hashtag__var_84) && encdec_vreg_backwards_matches(mapping1016_hashtag__var_83)))) && ((v__138.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__138.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping1013_hashtag_: BitVector<6> = v__138.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let vm: BitVector<1> = v__138.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1016_hashtag_: BitVector<5> = v__138.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1015_hashtag_: BitVector<5> = v__138.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1014_hashtag_: BitVector<5> = v__138.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1013_hashtag_: BitVector<6> = v__138.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_rmvvfunct6_backwards(mapping1013_hashtag_), encdec_vreg_backwards(mapping1014_hashtag_), encdec_vreg_backwards(mapping1015_hashtag_), encdec_vreg_backwards(mapping1016_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::RMVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__135 if {let mapping1017_hashtag__var_77: BitVector<6> = v__135.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1020_hashtag__var_78: BitVector<5> = v__135.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1019_hashtag__var_79: BitVector<5> = v__135.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1018_hashtag__var_80: BitVector<5> = v__135.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1017_hashtag__var_81: BitVector<6> = v__135.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_rfvvfunct6_backwards_matches(mapping1017_hashtag__var_81) && (encdec_vreg_backwards_matches(mapping1018_hashtag__var_80) && (encdec_vreg_backwards_matches(mapping1019_hashtag__var_79) && encdec_vreg_backwards_matches(mapping1020_hashtag__var_78)))) && ((v__135.subrange::<12, 15, 3>() == BitVector::<3>::new(0b001)) && (v__135.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111))))} => {let mapping1017_hashtag_: BitVector<6> = v__135.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let vm: BitVector<1> = v__135.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1020_hashtag_: BitVector<5> = v__135.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1019_hashtag_: BitVector<5> = v__135.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1018_hashtag_: BitVector<5> = v__135.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1017_hashtag_: BitVector<6> = v__135.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_rfvvfunct6_backwards(mapping1017_hashtag_), encdec_vreg_backwards(mapping1018_hashtag_), encdec_vreg_backwards(mapping1019_hashtag_), encdec_vreg_backwards(mapping1020_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_V)} => {Some(ast::RFVVTYPE((funct6, vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__131 if {let mapping1021_hashtag__var_74: BitVector<12> = v__131.subrange::<20, 32, 12>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1022_hashtag__var_75: BitVector<5> = v__131.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1021_hashtag__var_76: BitVector<12> = v__131.subrange::<20, 32, 12>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_cbop_backwards_matches(mapping1021_hashtag__var_76) && encdec_reg_backwards_matches(mapping1022_hashtag__var_75)) && (v__131.subrange::<0, 15, 15>() == BitVector::<15>::new(0b010000000001111)))} => {let mapping1021_hashtag_: BitVector<12> = v__131.subrange::<20, 32, 12>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1022_hashtag_: BitVector<5> = v__131.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1021_hashtag_: BitVector<12> = v__131.subrange::<20, 32, 12>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_cbop_backwards(mapping1021_hashtag_), encdec_reg_backwards(mapping1022_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (cbop, rs1) if {currentlyEnabled(core_ctx, extension::Ext_Zicbom)} => {Some(ast::ZICBOM((cbop, rs1)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__126 if {let mapping1023_hashtag__var_73: BitVector<5> = v__126.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (encdec_reg_backwards_matches(mapping1023_hashtag__var_73) && ((v__126.subrange::<20, 32, 12>() == BitVector::<12>::new(0b000000000100)) && (v__126.subrange::<0, 15, 15>() == BitVector::<15>::new(0b010000000001111))))} => {let mapping1023_hashtag_: BitVector<5> = v__126.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match encdec_reg_backwards(mapping1023_hashtag_) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rs1 if {currentlyEnabled(core_ctx, extension::Ext_Zicboz)} => {Some(ast::ZICBOZ(rs1))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__122 if {let mapping1026_hashtag__var_70: BitVector<5> = v__122.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1025_hashtag__var_71: BitVector<5> = v__122.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1024_hashtag__var_72: BitVector<5> = v__122.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1024_hashtag__var_72) && (encdec_vreg_backwards_matches(mapping1025_hashtag__var_71) && encdec_vreg_backwards_matches(mapping1026_hashtag__var_70))) && ((v__122.subrange::<26, 32, 6>() == BitVector::<6>::new(0b000001)) && ((v__122.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__122.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__122.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1026_hashtag_: BitVector<5> = v__122.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1025_hashtag_: BitVector<5> = v__122.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1024_hashtag_: BitVector<5> = v__122.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1024_hashtag_), encdec_vreg_backwards(mapping1025_hashtag_), encdec_vreg_backwards(mapping1026_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VANDN_VV((vm, vs1, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__118 if {let mapping1029_hashtag__var_67: BitVector<5> = v__118.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1028_hashtag__var_68: BitVector<5> = v__118.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1027_hashtag__var_69: BitVector<5> = v__118.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping1027_hashtag__var_69) && (encdec_reg_backwards_matches(mapping1028_hashtag__var_68) && encdec_vreg_backwards_matches(mapping1029_hashtag__var_67))) && ((v__118.subrange::<26, 32, 6>() == BitVector::<6>::new(0b000001)) && ((v__118.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__118.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__118.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1029_hashtag_: BitVector<5> = v__118.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1028_hashtag_: BitVector<5> = v__118.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1027_hashtag_: BitVector<5> = v__118.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping1027_hashtag_), encdec_reg_backwards(mapping1028_hashtag_), encdec_vreg_backwards(mapping1029_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VANDN_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__113 if {let mapping1031_hashtag__var_65: BitVector<5> = v__113.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1030_hashtag__var_66: BitVector<5> = v__113.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1030_hashtag__var_66) && encdec_vreg_backwards_matches(mapping1031_hashtag__var_65)) && ((v__113.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__113.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01010010)) && (v__113.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__113.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1031_hashtag_: BitVector<5> = v__113.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1030_hashtag_: BitVector<5> = v__113.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1030_hashtag_), encdec_vreg_backwards(mapping1031_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VBREV_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__108 if {let mapping1033_hashtag__var_63: BitVector<5> = v__108.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1032_hashtag__var_64: BitVector<5> = v__108.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1032_hashtag__var_64) && encdec_vreg_backwards_matches(mapping1033_hashtag__var_63)) && ((v__108.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__108.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01000010)) && (v__108.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__108.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1033_hashtag_: BitVector<5> = v__108.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1032_hashtag_: BitVector<5> = v__108.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1032_hashtag_), encdec_vreg_backwards(mapping1033_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VBREV8_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__103 if {let mapping1035_hashtag__var_61: BitVector<5> = v__103.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1034_hashtag__var_62: BitVector<5> = v__103.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1034_hashtag__var_62) && encdec_vreg_backwards_matches(mapping1035_hashtag__var_61)) && ((v__103.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__103.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01001010)) && (v__103.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__103.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1035_hashtag_: BitVector<5> = v__103.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1034_hashtag_: BitVector<5> = v__103.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1034_hashtag_), encdec_vreg_backwards(mapping1035_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VREV8_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__98 if {let mapping1037_hashtag__var_59: BitVector<5> = v__98.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1036_hashtag__var_60: BitVector<5> = v__98.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping1036_hashtag__var_60) && encdec_vreg_backwards_matches(mapping1037_hashtag__var_59)) && ((v__98.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__98.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01100010)) && (v__98.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__98.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1037_hashtag_: BitVector<5> = v__98.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1036_hashtag_: BitVector<5> = v__98.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping1036_hashtag_), encdec_vreg_backwards(mapping1037_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VCLZ_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__93 if {let mapping1039_hashtag__var_57: BitVector<5> = v__93.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1038_hashtag__var_58: BitVector<5> = v__93.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1038_hashtag__var_58) && encdec_vreg_backwards_matches(mapping1039_hashtag__var_57)) && ((v__93.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__93.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01101010)) && (v__93.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__93.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1039_hashtag_: BitVector<5> = v__93.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1038_hashtag_: BitVector<5> = v__93.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1038_hashtag_), encdec_vreg_backwards(mapping1039_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VCTZ_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__88 if {let mapping1041_hashtag__var_55: BitVector<5> = v__88.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1040_hashtag__var_56: BitVector<5> = v__88.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1040_hashtag__var_56) && encdec_vreg_backwards_matches(mapping1041_hashtag__var_55)) && ((v__88.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010010)) && ((v__88.subrange::<12, 20, 8>() == BitVector::<8>::new(0b01110010)) && (v__88.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__88.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1041_hashtag_: BitVector<5> = v__88.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1040_hashtag_: BitVector<5> = v__88.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1040_hashtag_), encdec_vreg_backwards(mapping1041_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VCPOP_V((vm, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__84 if {let mapping1044_hashtag__var_52: BitVector<5> = v__84.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1043_hashtag__var_53: BitVector<5> = v__84.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1042_hashtag__var_54: BitVector<5> = v__84.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1042_hashtag__var_54) && (encdec_vreg_backwards_matches(mapping1043_hashtag__var_53) && encdec_vreg_backwards_matches(mapping1044_hashtag__var_52))) && ((v__84.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010101)) && ((v__84.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__84.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__84.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1044_hashtag_: BitVector<5> = v__84.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1043_hashtag_: BitVector<5> = v__84.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1042_hashtag_: BitVector<5> = v__84.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1042_hashtag_), encdec_vreg_backwards(mapping1043_hashtag_), encdec_vreg_backwards(mapping1044_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VROL_VV((vm, vs1, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__80 if {let mapping1047_hashtag__var_49: BitVector<5> = v__80.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1046_hashtag__var_50: BitVector<5> = v__80.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1045_hashtag__var_51: BitVector<5> = v__80.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping1045_hashtag__var_51) && (encdec_reg_backwards_matches(mapping1046_hashtag__var_50) && encdec_vreg_backwards_matches(mapping1047_hashtag__var_49))) && ((v__80.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010101)) && ((v__80.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__80.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__80.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1047_hashtag_: BitVector<5> = v__80.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1046_hashtag_: BitVector<5> = v__80.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1045_hashtag_: BitVector<5> = v__80.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping1045_hashtag_), encdec_reg_backwards(mapping1046_hashtag_), encdec_vreg_backwards(mapping1047_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VROL_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__76 if {let mapping1050_hashtag__var_46: BitVector<5> = v__76.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1049_hashtag__var_47: BitVector<5> = v__76.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1048_hashtag__var_48: BitVector<5> = v__76.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1048_hashtag__var_48) && (encdec_vreg_backwards_matches(mapping1049_hashtag__var_47) && encdec_vreg_backwards_matches(mapping1050_hashtag__var_46))) && ((v__76.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__76.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__76.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__76.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1050_hashtag_: BitVector<5> = v__76.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1049_hashtag_: BitVector<5> = v__76.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1048_hashtag_: BitVector<5> = v__76.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1048_hashtag_), encdec_vreg_backwards(mapping1049_hashtag_), encdec_vreg_backwards(mapping1050_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VROR_VV((vm, vs1, vs2, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__72 if {let mapping1053_hashtag__var_43: BitVector<5> = v__72.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1052_hashtag__var_44: BitVector<5> = v__72.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1051_hashtag__var_45: BitVector<5> = v__72.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1051_hashtag__var_45) && (encdec_reg_backwards_matches(mapping1052_hashtag__var_44) && encdec_vreg_backwards_matches(mapping1053_hashtag__var_43))) && ((v__72.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__72.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__72.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__72.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1053_hashtag_: BitVector<5> = v__72.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1052_hashtag_: BitVector<5> = v__72.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1051_hashtag_: BitVector<5> = v__72.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1051_hashtag_), encdec_reg_backwards(mapping1052_hashtag_), encdec_vreg_backwards(mapping1053_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VROR_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__68 if {let mapping1055_hashtag__var_41: BitVector<5> = v__68.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1054_hashtag__var_42: BitVector<5> = v__68.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1054_hashtag__var_42) && encdec_vreg_backwards_matches(mapping1055_hashtag__var_41)) && ((v__68.subrange::<26, 32, 6>() == BitVector::<6>::new(0b010100)) && ((v__68.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__68.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__68.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let uimm: BitVector<5> = v__68.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1055_hashtag_: BitVector<5> = v__68.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1054_hashtag_: BitVector<5> = v__68.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1054_hashtag_), encdec_vreg_backwards(mapping1055_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvkb)} => {Some(ast::VROR_VI((vm, vs2, uimm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__64 if {let mapping1058_hashtag__var_38: BitVector<5> = v__64.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1057_hashtag__var_39: BitVector<5> = v__64.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1056_hashtag__var_40: BitVector<5> = v__64.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping1056_hashtag__var_40) && (encdec_vreg_backwards_matches(mapping1057_hashtag__var_39) && encdec_vreg_backwards_matches(mapping1058_hashtag__var_38))) && ((v__64.subrange::<26, 32, 6>() == BitVector::<6>::new(0b110101)) && ((v__64.subrange::<12, 15, 3>() == BitVector::<3>::new(0b000)) && (v__64.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__64.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1058_hashtag_: BitVector<5> = v__64.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1057_hashtag_: BitVector<5> = v__64.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1056_hashtag_: BitVector<5> = v__64.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping1056_hashtag_), encdec_vreg_backwards(mapping1057_hashtag_), encdec_vreg_backwards(mapping1058_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, vs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VWSLL_VV((vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__60 if {let mapping1061_hashtag__var_35: BitVector<5> = v__60.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1060_hashtag__var_36: BitVector<5> = v__60.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1059_hashtag__var_37: BitVector<5> = v__60.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1059_hashtag__var_37) && (encdec_reg_backwards_matches(mapping1060_hashtag__var_36) && encdec_vreg_backwards_matches(mapping1061_hashtag__var_35))) && ((v__60.subrange::<26, 32, 6>() == BitVector::<6>::new(0b110101)) && ((v__60.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__60.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__60.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1061_hashtag_: BitVector<5> = v__60.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1060_hashtag_: BitVector<5> = v__60.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1059_hashtag_: BitVector<5> = v__60.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1059_hashtag_), encdec_reg_backwards(mapping1060_hashtag_), encdec_vreg_backwards(mapping1061_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, rs1, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VWSLL_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__56 if {let mapping1063_hashtag__var_33: BitVector<5> = v__56.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1062_hashtag__var_34: BitVector<5> = v__56.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1062_hashtag__var_34) && encdec_vreg_backwards_matches(mapping1063_hashtag__var_33)) && ((v__56.subrange::<26, 32, 6>() == BitVector::<6>::new(0b110101)) && ((v__56.subrange::<12, 15, 3>() == BitVector::<3>::new(0b011)) && (v__56.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__56.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let uimm: BitVector<5> = v__56.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1063_hashtag_: BitVector<5> = v__56.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1062_hashtag_: BitVector<5> = v__56.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1062_hashtag_), encdec_vreg_backwards(mapping1063_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vd) if {currentlyEnabled(core_ctx, extension::Ext_Zvbb)} => {Some(ast::VWSLL_VI((vm, vs2, uimm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__52 if {let mapping1066_hashtag__var_30: BitVector<5> = v__52.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1065_hashtag__var_31: BitVector<5> = v__52.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1064_hashtag__var_32: BitVector<5> = v__52.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1064_hashtag__var_32) && (encdec_vreg_backwards_matches(mapping1065_hashtag__var_31) && encdec_vreg_backwards_matches(mapping1066_hashtag__var_30))) && ((v__52.subrange::<26, 32, 6>() == BitVector::<6>::new(0b001100)) && ((v__52.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__52.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__52.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1066_hashtag_: BitVector<5> = v__52.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1065_hashtag_: BitVector<5> = v__52.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1064_hashtag_: BitVector<5> = v__52.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1064_hashtag_), encdec_vreg_backwards(mapping1065_hashtag_), encdec_vreg_backwards(mapping1066_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {Some(ast::VCLMUL_VV((vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__48 if {let mapping1069_hashtag__var_27: BitVector<5> = v__48.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1068_hashtag__var_28: BitVector<5> = v__48.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1067_hashtag__var_29: BitVector<5> = v__48.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_vreg_backwards_matches(mapping1067_hashtag__var_29) && (encdec_reg_backwards_matches(mapping1068_hashtag__var_28) && encdec_vreg_backwards_matches(mapping1069_hashtag__var_27))) && ((v__48.subrange::<26, 32, 6>() == BitVector::<6>::new(0b001100)) && ((v__48.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__48.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__48.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1069_hashtag_: BitVector<5> = v__48.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1068_hashtag_: BitVector<5> = v__48.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1067_hashtag_: BitVector<5> = v__48.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_vreg_backwards(mapping1067_hashtag_), encdec_reg_backwards(mapping1068_hashtag_), encdec_vreg_backwards(mapping1069_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (vs2, rs1, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {Some(ast::VCLMUL_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__44 if {let mapping1072_hashtag__var_24: BitVector<5> = v__44.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1071_hashtag__var_25: BitVector<5> = v__44.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1070_hashtag__var_26: BitVector<5> = v__44.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1070_hashtag__var_26) && (encdec_vreg_backwards_matches(mapping1071_hashtag__var_25) && encdec_vreg_backwards_matches(mapping1072_hashtag__var_24))) && ((v__44.subrange::<26, 32, 6>() == BitVector::<6>::new(0b001101)) && ((v__44.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__44.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__44.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1072_hashtag_: BitVector<5> = v__44.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1071_hashtag_: BitVector<5> = v__44.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1070_hashtag_: BitVector<5> = v__44.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1070_hashtag_), encdec_vreg_backwards(mapping1071_hashtag_), encdec_vreg_backwards(mapping1072_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vs1, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {Some(ast::VCLMULH_VV((vm, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__40 if {let mapping1075_hashtag__var_21: BitVector<5> = v__40.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1074_hashtag__var_22: BitVector<5> = v__40.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1073_hashtag__var_23: BitVector<5> = v__40.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1073_hashtag__var_23) && (encdec_reg_backwards_matches(mapping1074_hashtag__var_22) && encdec_vreg_backwards_matches(mapping1075_hashtag__var_21))) && ((v__40.subrange::<26, 32, 6>() == BitVector::<6>::new(0b001101)) && ((v__40.subrange::<12, 15, 3>() == BitVector::<3>::new(0b110)) && (v__40.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1010111)))))} => {let vm: BitVector<1> = v__40.subrange::<25, 26, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1075_hashtag_: BitVector<5> = v__40.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1074_hashtag_: BitVector<5> = v__40.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1073_hashtag_: BitVector<5> = v__40.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1073_hashtag_), encdec_reg_backwards(mapping1074_hashtag_), encdec_vreg_backwards(mapping1075_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, rs1, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvbc) && ((get_sew(core_ctx, ()) == 64) as bool))} => {Some(ast::VCLMULH_VX((vm, vs2, rs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__36 if {let mapping1078_hashtag__var_18: BitVector<5> = v__36.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1077_hashtag__var_19: BitVector<5> = v__36.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1076_hashtag__var_20: BitVector<5> = v__36.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_vreg_backwards_matches(mapping1076_hashtag__var_20) && (encdec_vreg_backwards_matches(mapping1077_hashtag__var_19) && encdec_vreg_backwards_matches(mapping1078_hashtag__var_18))) && ((v__36.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1011011)) && ((v__36.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__36.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110111)))))} => {let mapping1078_hashtag_: BitVector<5> = v__36.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1077_hashtag_: BitVector<5> = v__36.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1076_hashtag_: BitVector<5> = v__36.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_vreg_backwards(mapping1076_hashtag_), encdec_vreg_backwards(mapping1077_hashtag_), encdec_vreg_backwards(mapping1078_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (vs2, vs1, vd) if {((currentlyEnabled(core_ctx, extension::Ext_Zvknha) && ((get_sew(core_ctx, ()) == 32) as bool)) || ((currentlyEnabled(core_ctx, extension::Ext_Zvknhb) && (((get_sew(core_ctx, ()) == 32) || ((get_sew(core_ctx, ()) == 64) as bool)) as bool)) && zvknhab_check_encdec(core_ctx, vs2, vs1, vd)))} => {Some(ast::VSHA2MS_VV((vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__32 if {let mapping1079_hashtag__var_13: BitVector<6> = v__32.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1082_hashtag__var_14: BitVector<5> = v__32.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1081_hashtag__var_15: BitVector<5> = v__32.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1080_hashtag__var_16: BitVector<5> = v__32.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1079_hashtag__var_17: BitVector<6> = v__32.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_zvkfunct6_backwards_matches(mapping1079_hashtag__var_17) && (encdec_vreg_backwards_matches(mapping1080_hashtag__var_16) && (encdec_vreg_backwards_matches(mapping1081_hashtag__var_15) && encdec_vreg_backwards_matches(mapping1082_hashtag__var_14)))) && ((v__32.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__32.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__32.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110111)))))} => {let mapping1079_hashtag_: BitVector<6> = v__32.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1082_hashtag_: BitVector<5> = v__32.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1081_hashtag_: BitVector<5> = v__32.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1080_hashtag_: BitVector<5> = v__32.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1079_hashtag_: BitVector<6> = v__32.subrange::<26, 32, 6>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_zvkfunct6_backwards(mapping1079_hashtag_), encdec_vreg_backwards(mapping1080_hashtag_), encdec_vreg_backwards(mapping1081_hashtag_), encdec_vreg_backwards(mapping1082_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (funct6, vs2, vs1, vd) if {((currentlyEnabled(core_ctx, extension::Ext_Zvknha) && ((get_sew(core_ctx, ()) == 32) as bool)) || ((currentlyEnabled(core_ctx, extension::Ext_Zvknhb) && (((get_sew(core_ctx, ()) == 32) || ((get_sew(core_ctx, ()) == 64) as bool)) as bool)) && zvknhab_check_encdec(core_ctx, vs2, vs1, vd)))} => {Some(ast::ZVKSHA2TYPE((funct6, vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        v__28 if {let mapping1085_hashtag__var_9: BitVector<5> = v__28.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1084_hashtag__var_10: BitVector<5> = v__28.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1083_hashtag__var_11: BitVector<5> = v__28.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((encdec_vreg_backwards_matches(mapping1083_hashtag__var_11) && (encdec_vreg_backwards_matches(mapping1084_hashtag__var_10) && encdec_vreg_backwards_matches(mapping1085_hashtag__var_9))) && ((v__28.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1000001)) && ((v__28.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__28.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110111)))))} => {let mapping1085_hashtag_: BitVector<5> = v__28.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1084_hashtag_: BitVector<5> = v__28.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mapping1083_hashtag_: BitVector<5> = v__28.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        match (encdec_vreg_backwards(mapping1083_hashtag_), encdec_vreg_backwards(mapping1084_hashtag_), encdec_vreg_backwards(mapping1085_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (vs2, vs1, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvksh) && (((get_sew(core_ctx, ()) == 32) && (zvk_check_encdec(core_ctx, 256, 8) && {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let var_12 = get_lmul_pow(core_ctx, ());
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zvk_valid_reg_overlap(vs2, vd, var_12)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                })) as bool))} => {Some(ast::VSM3ME_VV((vs2, vs1, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            v__24 if {let mapping1087_hashtag__var_6: BitVector<5> = v__24.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1086_hashtag__var_7: BitVector<5> = v__24.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((encdec_vreg_backwards_matches(mapping1086_hashtag__var_7) && encdec_vreg_backwards_matches(mapping1087_hashtag__var_6)) && ((v__24.subrange::<25, 32, 7>() == BitVector::<7>::new(0b1010111)) && ((v__24.subrange::<12, 15, 3>() == BitVector::<3>::new(0b010)) && (v__24.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110111)))))} => {let uimm: BitVector<5> = v__24.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1087_hashtag_: BitVector<5> = v__24.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mapping1086_hashtag_: BitVector<5> = v__24.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            match (encdec_vreg_backwards(mapping1086_hashtag_), encdec_vreg_backwards(mapping1087_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (vs2, vd) if {(currentlyEnabled(core_ctx, extension::Ext_Zvksh) && (((get_sew(core_ctx, ()) == 32) && (zvk_check_encdec(core_ctx, 256, 8) && {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let var_8 = get_lmul_pow(core_ctx, ());
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zvk_valid_reg_overlap(vs2, vd, var_8)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    })) as bool))} => {Some(ast::VSM3C_VI((vs2, uimm, vd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                v__18 if {let mapping1089_hashtag__var_4: BitVector<5> = v__18.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1088_hashtag__var_5: BitVector<5> = v__18.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ((encdec_reg_backwards_matches(mapping1088_hashtag__var_5) && encdec_reg_backwards_matches(mapping1089_hashtag__var_4)) && ((v__18.subrange::<31, 32, 1>() == BitVector::<1>::new(0b1)) && ((v__18.subrange::<28, 30, 2>() == BitVector::<2>::new(0b00)) && ((v__18.subrange::<22, 26, 4>() == BitVector::<4>::new(0b0111)) && ((v__18.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__18.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110011)))))))} => {let mop_30: BitVector<1> = v__18.subrange::<30, 31, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mop_27_26: BitVector<2> = v__18.subrange::<26, 28, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mop_21_20: BitVector<2> = v__18.subrange::<20, 22, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1089_hashtag_: BitVector<5> = v__18.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mapping1088_hashtag_: BitVector<5> = v__18.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                match (encdec_reg_backwards(mapping1088_hashtag_), encdec_reg_backwards(mapping1089_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zimop)} => {Some(ast::ZIMOP_MOP_R((bitvector_concat::<1, 4, 5>((mop_30 as BitVector<1>), bitvector_concat::<2, 2, 4>((mop_27_26 as BitVector<2>), (mop_21_20 as BitVector<2>))), rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                None => {match match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v__12 if {let mapping1092_hashtag__var_1: BitVector<5> = v__12.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1091_hashtag__var_2: BitVector<5> = v__12.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1090_hashtag__var_3: BitVector<5> = v__12.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((encdec_reg_backwards_matches(mapping1090_hashtag__var_3) && (encdec_reg_backwards_matches(mapping1091_hashtag__var_2) && encdec_reg_backwards_matches(mapping1092_hashtag__var_1))) && ((v__12.subrange::<31, 32, 1>() == BitVector::<1>::new(0b1)) && ((v__12.subrange::<28, 30, 2>() == BitVector::<2>::new(0b00)) && ((v__12.subrange::<25, 26, 1>() == BitVector::<1>::new(0b1)) && ((v__12.subrange::<12, 15, 3>() == BitVector::<3>::new(0b100)) && (v__12.subrange::<0, 7, 7>() == BitVector::<7>::new(0b1110011)))))))} => {let mop_30: BitVector<1> = v__12.subrange::<30, 31, 1>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mop_27_26: BitVector<2> = v__12.subrange::<26, 28, 2>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1092_hashtag_: BitVector<5> = v__12.subrange::<7, 12, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1091_hashtag_: BitVector<5> = v__12.subrange::<15, 20, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mapping1090_hashtag_: BitVector<5> = v__12.subrange::<20, 25, 5>();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    match (encdec_reg_backwards(mapping1090_hashtag_), encdec_reg_backwards(mapping1091_hashtag_), encdec_reg_backwards(mapping1092_hashtag_)) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rs2, rs1, rd) if {currentlyEnabled(core_ctx, extension::Ext_Zimop)} => {Some(ast::ZIMOP_MOP_RR((bitvector_concat::<1, 2, 3>((mop_30 as BitVector<1>), (mop_27_26 as BitVector<2>)), rs2, rs1, rd)))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {None}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Some(result) => {result}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    None => {match head_exp_hashtag_ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s => {ast::ILLEGAL(s)}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                                }}
                                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                            }}
                                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                        }}
                                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                    }}
                                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                                }}
                                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                                            }}
                                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                                        }}
                                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                                    }}
                                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                                }}
                                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                                            }}
                                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                                        }}
                                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                                    }}
                                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                                }}
                                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                                            }}
                                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                                        }}
                                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                                    }}
                                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                                }}
                                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                                            }}
                                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                                        }}
                                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                                    }}
                                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                                }}
                                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                                            }}
                                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                                        }}
                                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                                    }}
                                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                                }}
                                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                                            }}
                                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                                        }}
                                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                                    }}
                                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                                }}
                                                                                                                _ => {panic!("Unreachable code")}
                                                                                                            }}
                                                                                                            _ => {panic!("Unreachable code")}
                                                                                                        }}
                                                                                                        _ => {panic!("Unreachable code")}
                                                                                                    }}
                                                                                                    _ => {panic!("Unreachable code")}
                                                                                                }}
                                                                                                _ => {panic!("Unreachable code")}
                                                                                            }}
                                                                                            _ => {panic!("Unreachable code")}
                                                                                        }}
                                                                                        _ => {panic!("Unreachable code")}
                                                                                    }}
                                                                                    _ => {panic!("Unreachable code")}
                                                                                }}
                                                                                _ => {panic!("Unreachable code")}
                                                                            }}
                                                                            _ => {panic!("Unreachable code")}
                                                                        }}
                                                                        _ => {panic!("Unreachable code")}
                                                                    }}
                                                                    _ => {panic!("Unreachable code")}
                                                                }}
                                                                _ => {panic!("Unreachable code")}
                                                            }}
                                                            _ => {panic!("Unreachable code")}
                                                        }}
                                                        _ => {panic!("Unreachable code")}
                                                    }}
                                                    _ => {panic!("Unreachable code")}
                                                }}
                                                _ => {panic!("Unreachable code")}
                                            }}
                                            _ => {panic!("Unreachable code")}
                                        }}
                                        _ => {panic!("Unreachable code")}
                                    }}
                                    _ => {panic!("Unreachable code")}
                                }}
                                _ => {panic!("Unreachable code")}
                            }}
                            _ => {panic!("Unreachable code")}
                        }}
                        _ => {panic!("Unreachable code")}
                    }}
                    _ => {panic!("Unreachable code")}
                }}
                _ => {panic!("Unreachable code")}
            }}
            _ => {panic!("Unreachable code")}
        }}
        _ => {panic!("Unreachable code")}
    }
}

/// execute
/// 
/// Generated from the Sail sources at `riscv_insts_base.sail` L26-33.
pub fn execute(core_ctx: &mut Core, merge_hashtag_var: ast) -> ExecutionResult {
    match merge_hashtag_var {
        ast::UTYPE((imm, rd, op)) => {{
            let off: xlenbits = sign_extend(64, bitvector_concat::<20, 12, 32>(imm, BitVector::<12>::new(0b000000000000)));
            {
                let var_1 = match op {
                    uop::LUI => {off}
                    uop::AUIPC => {get_arch_pc(core_ctx, ()).wrapped_add(off)}
                    _ => {panic!("Unreachable code")}
                };
                wX_bits(core_ctx, rd, var_1)
            };
            RETIRE_SUCCESS
        }}
        ast::JAL((imm, rd)) => {{
            let target = core_ctx.PC.wrapped_add(sign_extend(64, imm));
            match ext_control_check_pc(target) {
                Ext_ControlAddr_Check::Ext_ControlAddr_Error(e) => {ExecutionResult::Ext_ControlAddr_Check_Failure(e)}
                Ext_ControlAddr_Check::Ext_ControlAddr_OK(target) => {{
                    let target_bits = bits_of_virtaddr(target);
                    if {(bit_to_bool(bitvector_access(target_bits, 1)) && !(currentlyEnabled(core_ctx, extension::Ext_Zca)))} {
                        ExecutionResult::Memory_Exception((target, ExceptionType::E_Fetch_Addr_Align(())))
                    } else {
                        {
                            let var_2 = get_next_pc(core_ctx, ());
                            wX_bits(core_ctx, rd, var_2)
                        };
                        set_next_pc(core_ctx, target_bits);
                        RETIRE_SUCCESS
                    }
                }}
                _ => {panic!("Unreachable code")}
            }
        }}
        ast::BTYPE((imm, rs2, rs1, op)) => {{
            let taken: bool = match op {
                bop::BEQ => {(rX_bits(core_ctx, rs1) == rX_bits(core_ctx, rs2))}
                bop::BNE => {(rX_bits(core_ctx, rs1) != rX_bits(core_ctx, rs2))}
                bop::BLT => {{
                    let var_3 = rX_bits(core_ctx, rs1);
                    let var_4 = rX_bits(core_ctx, rs2);
                    _operator_smaller_s_(var_3, var_4)
                }}
                bop::BGE => {{
                    let var_5 = rX_bits(core_ctx, rs1);
                    let var_6 = rX_bits(core_ctx, rs2);
                    _operator_biggerequal_s_(var_5, var_6)
                }}
                bop::BLTU => {{
                    let var_7 = rX_bits(core_ctx, rs1);
                    let var_8 = rX_bits(core_ctx, rs2);
                    _operator_smaller_u_(var_7, var_8)
                }}
                bop::BGEU => {{
                    let var_9 = rX_bits(core_ctx, rs1);
                    let var_10 = rX_bits(core_ctx, rs2);
                    _operator_biggerequal_u_(var_9, var_10)
                }}
                _ => {panic!("Unreachable code")}
            };
            if {taken} {
                let target = core_ctx.PC.wrapped_add(sign_extend(64, imm));
                match ext_control_check_pc(target) {
                    Ext_ControlAddr_Check::Ext_ControlAddr_Error(e) => {ExecutionResult::Ext_ControlAddr_Check_Failure(e)}
                    Ext_ControlAddr_Check::Ext_ControlAddr_OK(target) => {{
                        let target_bits = bits_of_virtaddr(target);
                        if {(bit_to_bool(bitvector_access(target_bits, 1)) && !(currentlyEnabled(core_ctx, extension::Ext_Zca)))} {
                            ExecutionResult::Memory_Exception((target, ExceptionType::E_Fetch_Addr_Align(())))
                        } else {
                            set_next_pc(core_ctx, target_bits);
                            RETIRE_SUCCESS
                        }
                    }}
                    _ => {panic!("Unreachable code")}
                }
            } else {
                RETIRE_SUCCESS
            }
        }}
        ast::ITYPE((imm, rs1, rd, op)) => {{
            let immext: xlenbits = sign_extend(64, imm);
            {
                let var_11 = match op {
                    iop::ADDI => {rX_bits(core_ctx, rs1).wrapped_add(immext)}
                    iop::SLTI => {{
                        let var_12 = {
                            let var_13 = rX_bits(core_ctx, rs1);
                            _operator_smaller_s_(var_13, immext)
                        };
                        bool_to_bits(var_12)
                    }.zero_extend::<64>()}
                    iop::SLTIU => {{
                        let var_14 = {
                            let var_15 = rX_bits(core_ctx, rs1);
                            _operator_smaller_u_(var_15, immext)
                        };
                        bool_to_bits(var_14)
                    }.zero_extend::<64>()}
                    iop::ANDI => {(rX_bits(core_ctx, rs1) & immext)}
                    iop::ORI => {(rX_bits(core_ctx, rs1) | immext)}
                    iop::XORI => {(rX_bits(core_ctx, rs1) ^ immext)}
                    _ => {panic!("Unreachable code")}
                };
                wX_bits(core_ctx, rd, var_11)
            };
            RETIRE_SUCCESS
        }}
        ast::SHIFTIOP((shamt, rs1, rd, op)) => {{
            {
                let var_16 = match op {
                    sop::SLLI => {shift_bits_left(rX_bits(core_ctx, rs1), shamt)}
                    sop::SRLI => {shift_bits_right(rX_bits(core_ctx, rs1), shamt)}
                    sop::SRAI => {{
                        let var_17 = rX_bits(core_ctx, rs1);
                        shift_bits_right_arith(var_17, shamt)
                    }}
                    _ => {panic!("Unreachable code")}
                };
                wX_bits(core_ctx, rd, var_16)
            };
            RETIRE_SUCCESS
        }}
        ast::RTYPE((rs2, rs1, rd, op)) => {{
            {
                let var_18 = match op {
                    rop::ADD => {{
                        let var_19 = rX_bits(core_ctx, rs2);
                        rX_bits(core_ctx, rs1).wrapped_add(var_19)
                    }}
                    rop::SLT => {{
                        let var_20 = {
                            let var_21 = rX_bits(core_ctx, rs1);
                            let var_22 = rX_bits(core_ctx, rs2);
                            _operator_smaller_s_(var_21, var_22)
                        };
                        bool_to_bits(var_20)
                    }.zero_extend::<64>()}
                    rop::SLTU => {{
                        let var_23 = {
                            let var_24 = rX_bits(core_ctx, rs1);
                            let var_25 = rX_bits(core_ctx, rs2);
                            _operator_smaller_u_(var_24, var_25)
                        };
                        bool_to_bits(var_23)
                    }.zero_extend::<64>()}
                    rop::AND => {(rX_bits(core_ctx, rs1) & rX_bits(core_ctx, rs2))}
                    rop::OR => {(rX_bits(core_ctx, rs1) | rX_bits(core_ctx, rs2))}
                    rop::XOR => {(rX_bits(core_ctx, rs1) ^ rX_bits(core_ctx, rs2))}
                    rop::SLL => {shift_bits_left(rX_bits(core_ctx, rs1), subrange_bits::<_, 6>(rX_bits(core_ctx, rs2), 5, 0))}
                    rop::SRL => {shift_bits_right(rX_bits(core_ctx, rs1), subrange_bits::<_, 6>(rX_bits(core_ctx, rs2), 5, 0))}
                    rop::SUB => {sub_vec(rX_bits(core_ctx, rs1), rX_bits(core_ctx, rs2))}
                    rop::SRA => {{
                        let var_26 = rX_bits(core_ctx, rs1);
                        let var_27 = subrange_bits::<_, 6>(rX_bits(core_ctx, rs2), 5, 0);
                        shift_bits_right_arith(var_26, var_27)
                    }}
                    _ => {panic!("Unreachable code")}
                };
                wX_bits(core_ctx, rd, var_18)
            };
            RETIRE_SUCCESS
        }}
        ast::LOAD((imm, rs1, rd, is_unsigned, width, aq, rl)) => {todo!("Unsupported: 'LOAD'")}
        ast::STORE((imm, rs2, rs1, width, aq, rl)) => {todo!("Unsupported: 'STORE'")}
        ast::ADDIW((imm, rs1, rd)) => {{
            let result = rX_bits(core_ctx, rs1).wrapped_add(sign_extend(64, imm));
            wX_bits(core_ctx, rd, sign_extend(64, result.subrange::<0, 32, 32>()));
            RETIRE_SUCCESS
        }}
        ast::RTYPEW((rs2, rs1, rd, op)) => {{
            let rs1_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let rs2_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0);
            let result: BitVector<32> = match op {
                ropw::ADDW => {rs1_val.wrapped_add(rs2_val)}
                ropw::SUBW => {sub_vec(rs1_val, rs2_val)}
                ropw::SLLW => {shift_bits_left(rs1_val, rs2_val.subrange::<0, 5, 5>())}
                ropw::SRLW => {shift_bits_right(rs1_val, rs2_val.subrange::<0, 5, 5>())}
                ropw::SRAW => {shift_bits_right_arith(rs1_val, rs2_val.subrange::<0, 5, 5>())}
                _ => {panic!("Unreachable code")}
            };
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::SHIFTIWOP((shamt, rs1, rd, op)) => {{
            let rs1_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let result: BitVector<32> = match op {
                sopw::SLLIW => {shift_bits_left(rs1_val, shamt)}
                sopw::SRLIW => {shift_bits_right(rs1_val, shamt)}
                sopw::SRAIW => {shift_bits_right_arith(rs1_val, shamt)}
                _ => {panic!("Unreachable code")}
            };
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::FENCE((pred, succ)) => {{
            let fiom = is_fiom_active(core_ctx, ());
            let pred = effective_fence_set(pred, fiom);
            let succ = effective_fence_set(succ, fiom);
            match (pred, succ) {
                (v__3756, v__3757) if {((v__3756.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)) && (v__3757.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)))} => {()}
                (v__3760, v__3761) if {((v__3760.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)) && (v__3761.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)))} => {()}
                (v__3764, v__3765) if {((v__3764.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)) && (v__3765.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)))} => {()}
                (v__3768, v__3769) if {((v__3768.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)) && (v__3769.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)))} => {()}
                (v__3772, v__3773) if {((v__3772.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)) && (v__3773.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)))} => {()}
                (v__3776, v__3777) if {((v__3776.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)) && (v__3777.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)))} => {()}
                (v__3780, v__3781) if {((v__3780.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)) && (v__3781.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)))} => {()}
                (v__3784, v__3785) if {((v__3784.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)) && (v__3785.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)))} => {()}
                (v__3788, v__3789) if {((v__3788.subrange::<0, 2, 2>() == BitVector::<2>::new(0b01)) && (v__3789.subrange::<0, 2, 2>() == BitVector::<2>::new(0b10)))} => {()}
                (_, v__3792) if {(v__3792.subrange::<0, 2, 2>() == BitVector::<2>::new(0b00))} => {()}
                (v__3794, _) if {(v__3794.subrange::<0, 2, 2>() == BitVector::<2>::new(0b00))} => {()}
                _ => {{
                    panic!("Unsupported function: 'print'")
                }}
                _ => {panic!("Unreachable code")}
            };
            RETIRE_SUCCESS
        }}
        ast::FENCE_TSO((pred, succ)) => {{
            match (pred, succ) {
                (v__3796, v__3797) if {((v__3796.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)) && (v__3797.subrange::<0, 2, 2>() == BitVector::<2>::new(0b11)))} => {()}
                (v__3800, v__3801) if {((v__3800.subrange::<0, 2, 2>() == BitVector::<2>::new(0b00)) && (v__3801.subrange::<0, 2, 2>() == BitVector::<2>::new(0b00)))} => {()}
                _ => {{
                    panic!("Unsupported function: 'print'")
                }}
                _ => {panic!("Unreachable code")}
            };
            RETIRE_SUCCESS
        }}
        ast::ECALL(()) => {{
            let t: sync_exception = sync_exception {
                trap: match core_ctx.cur_privilege {
                    Privilege::User => {ExceptionType::E_U_EnvCall(())}
                    Privilege::Supervisor => {ExceptionType::E_S_EnvCall(())}
                    Privilege::Machine => {ExceptionType::E_M_EnvCall(())}
                    _ => {panic!("Unreachable code")}
                },
                excinfo: (None as Option<xlenbits>),
                ext: None
            };
            ExecutionResult::Trap((core_ctx.cur_privilege, ctl_result::CTL_TRAP(t), core_ctx.PC))
        }}
        ast::MRET(()) => {{
            if {(core_ctx.cur_privilege != Privilege::Machine)} {
                ExecutionResult::Illegal_Instruction(())
            } else if {!(true)} {
                ExecutionResult::Ext_XRET_Priv_Failure(())
            } else {
                {
                    let var_28 = {
                        let var_29 = core_ctx.cur_privilege;
                        let var_30 = core_ctx.PC;
                        exception_handler(core_ctx, var_29, ctl_result::CTL_MRET(()), var_30)
                    };
                    set_next_pc(core_ctx, var_28)
                };
                RETIRE_SUCCESS
            }
        }}
        ast::SRET(()) => {{
            let sret_illegal: bool = match core_ctx.cur_privilege {
                Privilege::User => {true}
                Privilege::Supervisor => {(!(currentlyEnabled(core_ctx, extension::Ext_S)) || ({
                    let var_34 = core_ctx.mstatus;
                    _get_Mstatus_TSR(var_34)
                } == BitVector::<1>::new(0b1)))}
                Privilege::Machine => {!(currentlyEnabled(core_ctx, extension::Ext_S))}
                _ => {panic!("Unreachable code")}
            };
            if {sret_illegal} {
                ExecutionResult::Illegal_Instruction(())
            } else if {!(true)} {
                ExecutionResult::Ext_XRET_Priv_Failure(())
            } else {
                {
                    let var_31 = {
                        let var_32 = core_ctx.cur_privilege;
                        let var_33 = core_ctx.PC;
                        exception_handler(core_ctx, var_32, ctl_result::CTL_SRET(()), var_33)
                    };
                    set_next_pc(core_ctx, var_31)
                };
                RETIRE_SUCCESS
            }
        }}
        ast::EBREAK(()) => {ExecutionResult::Memory_Exception(({
            let var_35 = core_ctx.PC;
            virtaddr::Virtaddr(var_35)
        }, ExceptionType::E_Breakpoint(())))}
        ast::WFI(()) => {match core_ctx.cur_privilege {
            Privilege::Machine => {ExecutionResult::Wait_For_Interrupt(())}
            Privilege::Supervisor => {if {({
                let var_36 = core_ctx.mstatus;
                _get_Mstatus_TW(var_36)
            } == BitVector::<1>::new(0b1))} {
                ExecutionResult::Illegal_Instruction(())
            } else {
                ExecutionResult::Wait_For_Interrupt(())
            }}
            Privilege::User => {ExecutionResult::Illegal_Instruction(())}
            _ => {panic!("Unreachable code")}
        }}
        ast::SFENCE_VMA((rs1, rs2)) => {{
            let addr = if {(rs1 != zreg)} {
                Some(rX_bits(core_ctx, rs1))
            } else {
                None
            };
            let asid = if {(rs2 != zreg)} {
                Some(subrange_bits::<_, 16>(rX_bits(core_ctx, rs2), 15, 0))
            } else {
                None
            };
            match core_ctx.cur_privilege {
                Privilege::User => {ExecutionResult::Illegal_Instruction(())}
                Privilege::Supervisor => {match {
                    let var_37 = core_ctx.mstatus;
                    _get_Mstatus_TVM(var_37)
                } {
                    b__0 if {(b__0 == BitVector::<1>::new(0b1))} => {ExecutionResult::Illegal_Instruction(())}
                    _ => {{
                        flush_TLB(core_ctx, asid, addr);
                        RETIRE_SUCCESS
                    }}
                    _ => {panic!("Unreachable code")}
                }}
                Privilege::Machine => {{
                    flush_TLB(core_ctx, asid, addr);
                    RETIRE_SUCCESS
                }}
                _ => {panic!("Unreachable code")}
            }
        }}
        ast::FENCEI(()) => {{
            RETIRE_SUCCESS
        }}
        ast::LOADRES((aq, rl, rs1, width, rd)) => {todo!("Unsupported: 'LOADRES'")}
        ast::STORECON((aq, rl, rs2, rs1, width, rd)) => {todo!("Unsupported: 'STORECON'")}
        ast::AMO((op, aq, rl, rs2, rs1, width, rd)) => {todo!("Unsupported: 'AMO'")}
        ast::C_NOP(()) => {RETIRE_SUCCESS}
        ast::C_ADDI4SPN((rdc, nzimm)) => {{
            let imm: BitVector<12> = bitvector_concat::<2, 10, 12>(BitVector::<2>::new(0b00), bitvector_concat::<8, 2, 10>(nzimm, BitVector::<2>::new(0b00)));
            let rd = creg2reg_idx(rdc);
            execute(core_ctx, ast::ITYPE((imm, sp, rd, iop::ADDI)))
        }}
        ast::C_LW((uimm, rsc, rdc)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 2, 7>(uimm, BitVector::<2>::new(0b00)).zero_extend::<12>();
            let rd = creg2reg_idx(rdc);
            let rs = creg2reg_idx(rsc);
            execute(core_ctx, ast::LOAD((imm, rs, rd, false, word_width::WORD, false, false)))
        }}
        ast::C_LD((uimm, rsc, rdc)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 3, 8>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            let rd = creg2reg_idx(rdc);
            let rs = creg2reg_idx(rsc);
            execute(core_ctx, ast::LOAD((imm, rs, rd, false, word_width::DOUBLE, false, false)))
        }}
        ast::C_SW((uimm, rsc1, rsc2)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 2, 7>(uimm, BitVector::<2>::new(0b00)).zero_extend::<12>();
            let rs1 = creg2reg_idx(rsc1);
            let rs2 = creg2reg_idx(rsc2);
            execute(core_ctx, ast::STORE((imm, rs2, rs1, word_width::WORD, false, false)))
        }}
        ast::C_SD((uimm, rsc1, rsc2)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 3, 8>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            let rs1 = creg2reg_idx(rsc1);
            let rs2 = creg2reg_idx(rsc2);
            execute(core_ctx, ast::STORE((imm, rs2, rs1, word_width::DOUBLE, false, false)))
        }}
        ast::C_ADDI((nzi, rsd)) => {{
            let imm: BitVector<12> = sign_extend(12, nzi);
            execute(core_ctx, ast::ITYPE((imm, rsd, rsd, iop::ADDI)))
        }}
        ast::C_JAL(imm) => {execute(core_ctx, ast::JAL((sign_extend(21, bitvector_concat::<11, 1, 12>(imm, BitVector::<1>::new(0b0))), ra)))}
        ast::C_ADDIW((imm, rsd)) => {execute(core_ctx, ast::ADDIW((sign_extend(12, imm), rsd, rsd)))}
        ast::C_LI((imm, rd)) => {{
            let imm: BitVector<12> = sign_extend(12, imm);
            execute(core_ctx, ast::ITYPE((imm, zreg, rd, iop::ADDI)))
        }}
        ast::C_ADDI16SP(imm) => {{
            let imm: BitVector<12> = sign_extend(12, bitvector_concat::<6, 4, 10>(imm, BitVector::<4>::new(0b0000)));
            execute(core_ctx, ast::ITYPE((imm, sp, sp, iop::ADDI)))
        }}
        ast::C_LUI((imm, rd)) => {{
            let res: BitVector<20> = sign_extend(20, imm);
            execute(core_ctx, ast::UTYPE((res, rd, uop::LUI)))
        }}
        ast::C_SRLI((shamt, rsd)) => {{
            let rsd = creg2reg_idx(rsd);
            execute(core_ctx, ast::SHIFTIOP((shamt, rsd, rsd, sop::SRLI)))
        }}
        ast::C_SRAI((shamt, rsd)) => {{
            let rsd = creg2reg_idx(rsd);
            execute(core_ctx, ast::SHIFTIOP((shamt, rsd, rsd, sop::SRAI)))
        }}
        ast::C_ANDI((imm, rsd)) => {{
            let rsd = creg2reg_idx(rsd);
            execute(core_ctx, ast::ITYPE((sign_extend(12, imm), rsd, rsd, iop::ANDI)))
        }}
        ast::C_SUB((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPE((rs2, rsd, rsd, rop::SUB)))
        }}
        ast::C_XOR((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPE((rs2, rsd, rsd, rop::XOR)))
        }}
        ast::C_OR((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPE((rs2, rsd, rsd, rop::OR)))
        }}
        ast::C_AND((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPE((rs2, rsd, rsd, rop::AND)))
        }}
        ast::C_SUBW((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPEW((rs2, rsd, rsd, ropw::SUBW)))
        }}
        ast::C_ADDW((rsd, rs2)) => {{
            let rsd = creg2reg_idx(rsd);
            let rs2 = creg2reg_idx(rs2);
            execute(core_ctx, ast::RTYPEW((rs2, rsd, rsd, ropw::ADDW)))
        }}
        ast::C_J(imm) => {execute(core_ctx, ast::JAL((sign_extend(21, bitvector_concat::<11, 1, 12>(imm, BitVector::<1>::new(0b0))), zreg)))}
        ast::C_BEQZ((imm, rs)) => {execute(core_ctx, ast::BTYPE((sign_extend(13, bitvector_concat::<8, 1, 9>(imm, BitVector::<1>::new(0b0))), zreg, creg2reg_idx(rs), bop::BEQ)))}
        ast::C_BNEZ((imm, rs)) => {execute(core_ctx, ast::BTYPE((sign_extend(13, bitvector_concat::<8, 1, 9>(imm, BitVector::<1>::new(0b0))), zreg, creg2reg_idx(rs), bop::BNE)))}
        ast::C_SLLI((shamt, rsd)) => {execute(core_ctx, ast::SHIFTIOP((shamt, rsd, rsd, sop::SLLI)))}
        ast::C_LWSP((uimm, rd)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 2, 8>(uimm, BitVector::<2>::new(0b00)).zero_extend::<12>();
            execute(core_ctx, ast::LOAD((imm, sp, rd, false, word_width::WORD, false, false)))
        }}
        ast::C_LDSP((uimm, rd)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 3, 9>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            execute(core_ctx, ast::LOAD((imm, sp, rd, false, word_width::DOUBLE, false, false)))
        }}
        ast::C_SWSP((uimm, rs2)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 2, 8>(uimm, BitVector::<2>::new(0b00)).zero_extend::<12>();
            execute(core_ctx, ast::STORE((imm, rs2, sp, word_width::WORD, false, false)))
        }}
        ast::C_SDSP((uimm, rs2)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 3, 9>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            execute(core_ctx, ast::STORE((imm, rs2, sp, word_width::DOUBLE, false, false)))
        }}
        ast::C_JR(rs1) => {execute(core_ctx, ast::JALR((zeros::<12>(12), rs1, zreg)))}
        ast::C_JALR(rs1) => {execute(core_ctx, ast::JALR((zeros::<12>(12), rs1, ra)))}
        ast::C_MV((rd, rs2)) => {execute(core_ctx, ast::RTYPE((rs2, zreg, rd, rop::ADD)))}
        ast::C_EBREAK(()) => {execute(core_ctx, ast::EBREAK(()))}
        ast::C_ADD((rsd, rs2)) => {execute(core_ctx, ast::RTYPE((rs2, rsd, rsd, rop::ADD)))}
        ast::MUL((rs2, rs1, rd, mul_op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let rs1_int: i128 = if {mul_op.signed_rs1} {
                rs1_val.signed()
            } else {
                rs1_val.unsigned()
            };
            let rs2_int: i128 = if {mul_op.signed_rs2} {
                rs2_val.signed()
            } else {
                rs2_val.unsigned()
            };
            let result_wide = to_bits::<128>(128, (rs1_int * rs2_int));
            let result = if {mul_op.high} {
                result_wide.subrange::<64, 128, 64>()
            } else {
                result_wide.subrange::<0, 64, 64>()
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::DIV((rs2, rs1, rd, s)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let rs1_int: i128 = if {s} {
                rs1_val.signed()
            } else {
                rs1_val.unsigned()
            };
            let rs2_int: i128 = if {s} {
                rs2_val.signed()
            } else {
                rs2_val.unsigned()
            };
            let q: i128 = if {(rs2_int == 0)} {
                -1
            } else {
                quot_round_zero(rs1_int, rs2_int)
            };
            let q__quote: i128 = if {(s && (q > 9223372036854775807))} {
                -9223372036854775808
            } else {
                q
            };
            wX_bits(core_ctx, rd, to_bits::<64>(64, q__quote));
            RETIRE_SUCCESS
        }}
        ast::REM((rs2, rs1, rd, s)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let rs1_int: i128 = if {s} {
                rs1_val.signed()
            } else {
                rs1_val.unsigned()
            };
            let rs2_int: i128 = if {s} {
                rs2_val.signed()
            } else {
                rs2_val.unsigned()
            };
            let r: i128 = if {(rs2_int == 0)} {
                rs1_int
            } else {
                rem_round_zero(rs1_int, rs2_int)
            };
            wX_bits(core_ctx, rd, to_bits::<64>(64, r));
            RETIRE_SUCCESS
        }}
        ast::MULW((rs2, rs1, rd)) => {{
            let rs1_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let rs2_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0);
            let rs1_int: i128 = rs1_val.signed();
            let rs2_int: i128 = rs2_val.signed();
            let result32 = subrange_bits::<_, 32>(to_bits::<64>(64, (rs1_int * rs2_int)), 31, 0);
            let result: xlenbits = sign_extend(64, result32);
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::DIVW((rs2, rs1, rd, s)) => {{
            let rs1_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let rs2_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0);
            let rs1_int: i128 = if {s} {
                rs1_val.signed()
            } else {
                rs1_val.unsigned()
            };
            let rs2_int: i128 = if {s} {
                rs2_val.signed()
            } else {
                rs2_val.unsigned()
            };
            let q: i128 = if {(rs2_int == 0)} {
                -1
            } else {
                quot_round_zero(rs1_int, rs2_int)
            };
            let q__quote: i128 = if {(s && (q > 2147483647))} {
                -2147483648
            } else {
                q
            };
            wX_bits(core_ctx, rd, sign_extend(64, to_bits::<32>(32, q__quote)));
            RETIRE_SUCCESS
        }}
        ast::REMW((rs2, rs1, rd, s)) => {{
            let rs1_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let rs2_val = subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0);
            let rs1_int: i128 = if {s} {
                rs1_val.signed()
            } else {
                rs1_val.unsigned()
            };
            let rs2_int: i128 = if {s} {
                rs2_val.signed()
            } else {
                rs2_val.unsigned()
            };
            let r: i128 = if {(rs2_int == 0)} {
                rs1_int
            } else {
                rem_round_zero(rs1_int, rs2_int)
            };
            wX_bits(core_ctx, rd, sign_extend(64, to_bits::<32>(32, r)));
            RETIRE_SUCCESS
        }}
        ast::CSRReg((csr, rs1, rd, op)) => {{
            let var_38 = rX_bits(core_ctx, rs1);
            doCSR(core_ctx, csr, var_38, rd, op, ((op == csrop::CSRRW) || (rs1 != zreg)))
        }}
        ast::CSRImm((csr, imm, rd, op)) => {doCSR(core_ctx, csr, imm.zero_extend::<64>(), rd, op, ((op == csrop::CSRRW) || (imm != zeros::<5>(5))))}
        ast::C_NOP_HINT(imm) => {RETIRE_SUCCESS}
        ast::C_ADDI_HINT(rsd) => {RETIRE_SUCCESS}
        ast::C_LI_HINT(imm) => {RETIRE_SUCCESS}
        ast::C_LUI_HINT(imm) => {RETIRE_SUCCESS}
        ast::C_MV_HINT(rs2) => {RETIRE_SUCCESS}
        ast::C_ADD_HINT(rs2) => {RETIRE_SUCCESS}
        ast::C_SLLI_HINT((shamt, rsd)) => {RETIRE_SUCCESS}
        ast::C_SRLI_HINT(rsd) => {RETIRE_SUCCESS}
        ast::C_SRAI_HINT(rsd) => {RETIRE_SUCCESS}
        ast::FENCE_RESERVED((fm, pred, succ, rs, rd)) => {RETIRE_SUCCESS}
        ast::FENCEI_RESERVED((imm, rs, rd)) => {RETIRE_SUCCESS}
        ast::LOAD_FP((imm, rs1, rd, width)) => {todo!("Unsupported: 'LOAD_FP'")}
        ast::STORE_FP((imm, rs2, rs1, width)) => {todo!("Unsupported: 'STORE_FP'")}
        ast::F_MADD_TYPE_S((rs3, rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_MADD_TYPE_S'")}
        ast::F_BIN_RM_TYPE_S((rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_BIN_RM_TYPE_S'")}
        ast::F_UN_RM_FF_TYPE_S((rs1, rm, rd, f_un_rm_ff_op_S::FSQRT_S)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_W_S)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_WU_S)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_W)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_WU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_L_S)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_FX_TYPE_S((rs1, rm, rd, f_un_rm_fx_op_S::FCVT_LU_S)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_L)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_UN_RM_XF_TYPE_S((rs1, rm, rd, f_un_rm_xf_op_S::FCVT_S_LU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJ_S)) => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJN_S)) => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FSGNJX_S)) => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMIN_S)) => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_F_S((rs2, rs1, rd, f_bin_op_f_S::FMAX_S)) => {todo!("Unsupported: 'F_BIN_TYPE_F_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FEQ_S)) => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLT_S)) => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_BIN_TYPE_X_S((rs2, rs1, rd, f_bin_op_x_S::FLE_S)) => {todo!("Unsupported: 'F_BIN_TYPE_X_S'")}
        ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FCLASS_S)) => {todo!("Unsupported: 'F_UN_TYPE_X_S'")}
        ast::F_UN_TYPE_X_S((rs1, rd, f_un_op_x_S::FMV_X_W)) => {todo!("Unsupported: 'F_UN_TYPE_X_S'")}
        ast::F_UN_TYPE_F_S((rs1, rd, f_un_op_f_S::FMV_W_X)) => {todo!("Unsupported: 'F_UN_TYPE_F_S'")}
        ast::C_FLWSP((imm, rd)) => {todo!("Unsupported: 'C_FLWSP'")}
        ast::C_FSWSP((uimm, rs2)) => {todo!("Unsupported: 'C_FSWSP'")}
        ast::C_FLW((uimm, rsc, rdc)) => {todo!("Unsupported: 'C_FLW'")}
        ast::C_FSW((uimm, rsc1, rsc2)) => {todo!("Unsupported: 'C_FSW'")}
        ast::F_MADD_TYPE_D((rs3, rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_MADD_TYPE_D'")}
        ast::F_BIN_RM_TYPE_D((rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_BIN_RM_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FSQRT_D)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_W_D)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_WU_D)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_W)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_WU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_S_D)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FF_TYPE_D((rs1, rm, rd, f_un_rm_ff_op_D::FCVT_D_S)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_L_D)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_FX_TYPE_D((rs1, rm, rd, f_un_rm_fx_op_D::FCVT_LU_D)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_L)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_UN_RM_XF_TYPE_D((rs1, rm, rd, f_un_rm_xf_op_D::FCVT_D_LU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJ_D)) => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJN_D)) => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FSGNJX_D)) => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMIN_D)) => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_F_TYPE_D((rs2, rs1, rd, f_bin_f_op_D::FMAX_D)) => {todo!("Unsupported: 'F_BIN_F_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FEQ_D)) => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLT_D)) => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_BIN_X_TYPE_D((rs2, rs1, rd, f_bin_x_op_D::FLE_D)) => {todo!("Unsupported: 'F_BIN_X_TYPE_D'")}
        ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FCLASS_D)) => {todo!("Unsupported: 'F_UN_X_TYPE_D'")}
        ast::F_UN_X_TYPE_D((rs1, rd, f_un_x_op_D::FMV_X_D)) => {todo!("Unsupported: 'F_UN_X_TYPE_D'")}
        ast::F_UN_F_TYPE_D((rs1, rd, f_un_f_op_D::FMV_D_X)) => {todo!("Unsupported: 'F_UN_F_TYPE_D'")}
        ast::C_FLDSP((uimm, rd)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 3, 9>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            execute(core_ctx, ast::LOAD_FP((imm, sp, rd, word_width::DOUBLE)))
        }}
        ast::C_FSDSP((uimm, rs2)) => {{
            let imm: BitVector<12> = bitvector_concat::<6, 3, 9>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            execute(core_ctx, ast::STORE_FP((imm, rs2, sp, word_width::DOUBLE)))
        }}
        ast::C_FLD((uimm, rsc, rdc)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 3, 8>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            let rd = cregidx_to_fregidx(rdc);
            let rs = creg2reg_idx(rsc);
            execute(core_ctx, ast::LOAD_FP((imm, rs, rd, word_width::DOUBLE)))
        }}
        ast::C_FSD((uimm, rsc1, rsc2)) => {{
            let imm: BitVector<12> = bitvector_concat::<5, 3, 8>(uimm, BitVector::<3>::new(0b000)).zero_extend::<12>();
            let rs1 = creg2reg_idx(rsc1);
            let rs2 = cregidx_to_fregidx(rsc2);
            execute(core_ctx, ast::STORE_FP((imm, rs2, rs1, word_width::DOUBLE)))
        }}
        ast::SINVAL_VMA((rs1, rs2)) => {{
            execute(core_ctx, ast::SFENCE_VMA((rs1, rs2)))
        }}
        ast::SFENCE_W_INVAL(()) => {{
            if {(core_ctx.cur_privilege == Privilege::User)} {
                ExecutionResult::Illegal_Instruction(())
            } else {
                RETIRE_SUCCESS
            }
        }}
        ast::SFENCE_INVAL_IR(()) => {{
            if {(core_ctx.cur_privilege == Privilege::User)} {
                ExecutionResult::Illegal_Instruction(())
            } else {
                RETIRE_SUCCESS
            }
        }}
        ast::SLLIUW((shamt, rs1, rd)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let result: xlenbits = shift_bits_left(rs1_val.subrange::<0, 32, 32>().zero_extend::<64>(), shamt);
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::ZBA_RTYPEUW((rs2, rs1, rd, op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let shamt: BitVector<2> = match op {
                bropw_zba::ADDUW => {BitVector::<2>::new(0b00)}
                bropw_zba::SH1ADDUW => {BitVector::<2>::new(0b01)}
                bropw_zba::SH2ADDUW => {BitVector::<2>::new(0b10)}
                bropw_zba::SH3ADDUW => {BitVector::<2>::new(0b11)}
                _ => {panic!("Unreachable code")}
            };
            let result: xlenbits = shift_bits_left(rs1_val.subrange::<0, 32, 32>().zero_extend::<64>(), shamt).wrapped_add(rs2_val);
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::ZBA_RTYPE((rs2, rs1, rd, op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let shamt: BitVector<2> = match op {
                brop_zba::SH1ADD => {BitVector::<2>::new(0b01)}
                brop_zba::SH2ADD => {BitVector::<2>::new(0b10)}
                brop_zba::SH3ADD => {BitVector::<2>::new(0b11)}
                _ => {panic!("Unreachable code")}
            };
            let result: xlenbits = shift_bits_left(rs1_val, shamt).wrapped_add(rs2_val);
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::RORIW((shamt, rs1, rd)) => {todo!("Unsupported: 'RORIW'")}
        ast::RORI((shamt, rs1, rd)) => {todo!("Unsupported: 'RORI'")}
        ast::ZBB_RTYPEW((rs2, rs1, rd, op)) => {todo!("Unsupported: 'ZBB_RTYPEW'")}
        ast::ZBB_RTYPE((rs2, rs1, rd, op)) => {todo!("Unsupported: 'ZBB_RTYPE'")}
        ast::ZBB_EXTOP((rs1, rd, op)) => {todo!("Unsupported: 'ZBB_EXTOP'")}
        ast::REV8((rs1, rd)) => {todo!("Unsupported: 'REV8'")}
        ast::ORCB((rs1, rd)) => {todo!("Unsupported: 'ORCB'")}
        ast::CPOP((rs1, rd)) => {todo!("Unsupported: 'CPOP'")}
        ast::CPOPW((rs1, rd)) => {todo!("Unsupported: 'CPOPW'")}
        ast::CLZ((rs1, rd)) => {todo!("Unsupported: 'CLZ'")}
        ast::CLZW((rs1, rd)) => {todo!("Unsupported: 'CLZW'")}
        ast::CTZ((rs1, rd)) => {todo!("Unsupported: 'CTZ'")}
        ast::CTZW((rs1, rd)) => {todo!("Unsupported: 'CTZW'")}
        ast::CLMUL((rs2, rs1, rd)) => {todo!("Unsupported: 'CLMUL'")}
        ast::CLMULH((rs2, rs1, rd)) => {todo!("Unsupported: 'CLMULH'")}
        ast::CLMULR((rs2, rs1, rd)) => {todo!("Unsupported: 'CLMULR'")}
        ast::ZBS_IOP((shamt, rs1, rd, op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let mask: xlenbits = shift_bits_left(BitVector::<1>::new(0b1).zero_extend::<64>(), shamt);
            let result: xlenbits = match op {
                biop_zbs::BCLRI => {(rs1_val & !(mask))}
                biop_zbs::BEXTI => {bool_to_bits(((rs1_val & mask) != zeros::<64>(64))).zero_extend::<64>()}
                biop_zbs::BINVI => {(rs1_val ^ mask)}
                biop_zbs::BSETI => {(rs1_val | mask)}
                _ => {panic!("Unreachable code")}
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::ZBS_RTYPE((rs2, rs1, rd, op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let mask: xlenbits = shift_bits_left(BitVector::<1>::new(0b1).zero_extend::<64>(), rs2_val.subrange::<0, 6, 6>());
            let result: xlenbits = match op {
                brop_zbs::BCLR => {(rs1_val & !(mask))}
                brop_zbs::BEXT => {bool_to_bits(((rs1_val & mask) != zeros::<64>(64))).zero_extend::<64>()}
                brop_zbs::BINV => {(rs1_val ^ mask)}
                brop_zbs::BSET => {(rs1_val | mask)}
                _ => {panic!("Unreachable code")}
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::C_LBU((uimm, rdc, rs1c)) => {{
            let imm: BitVector<12> = uimm.zero_extend::<12>();
            let rd = creg2reg_idx(rdc);
            let rs1 = creg2reg_idx(rs1c);
            execute(core_ctx, ast::LOAD((imm, rs1, rd, true, word_width::BYTE, false, false)))
        }}
        ast::C_LHU((uimm, rdc, rs1c)) => {{
            let imm: BitVector<12> = uimm.zero_extend::<12>();
            let rd = creg2reg_idx(rdc);
            let rs1 = creg2reg_idx(rs1c);
            execute(core_ctx, ast::LOAD((imm, rs1, rd, true, word_width::HALF, false, false)))
        }}
        ast::C_LH((uimm, rdc, rs1c)) => {{
            let imm: BitVector<12> = uimm.zero_extend::<12>();
            let rd = creg2reg_idx(rdc);
            let rs1 = creg2reg_idx(rs1c);
            execute(core_ctx, ast::LOAD((imm, rs1, rd, false, word_width::HALF, false, false)))
        }}
        ast::C_SB((uimm, rs1c, rs2c)) => {{
            let imm: BitVector<12> = uimm.zero_extend::<12>();
            let rs1 = creg2reg_idx(rs1c);
            let rs2 = creg2reg_idx(rs2c);
            execute(core_ctx, ast::STORE((imm, rs2, rs1, word_width::BYTE, false, false)))
        }}
        ast::C_SH((uimm, rs1c, rs2c)) => {{
            let imm: BitVector<12> = uimm.zero_extend::<12>();
            let rs1 = creg2reg_idx(rs1c);
            let rs2 = creg2reg_idx(rs2c);
            execute(core_ctx, ast::STORE((imm, rs2, rs1, word_width::HALF, false, false)))
        }}
        ast::C_ZEXT_B(rsdc) => {{
            let rsd = creg2reg_idx(rsdc);
            {
                let var_39 = subrange_bits::<_, 8>(rX_bits(core_ctx, rsd), 7, 0).zero_extend::<64>();
                wX_bits(core_ctx, rsd, var_39)
            };
            RETIRE_SUCCESS
        }}
        ast::C_SEXT_B(rsdc) => {{
            let rsd = creg2reg_idx(rsdc);
            execute(core_ctx, ast::ZBB_EXTOP((rsd, rsd, extop_zbb::SEXTB)))
        }}
        ast::C_ZEXT_H(rsdc) => {{
            let rsd = creg2reg_idx(rsdc);
            execute(core_ctx, ast::ZBB_EXTOP((rsd, rsd, extop_zbb::ZEXTH)))
        }}
        ast::C_SEXT_H(rsdc) => {{
            let rsd = creg2reg_idx(rsdc);
            execute(core_ctx, ast::ZBB_EXTOP((rsd, rsd, extop_zbb::SEXTH)))
        }}
        ast::C_ZEXT_W(rsdc) => {{
            let rsd = creg2reg_idx(rsdc);
            execute(core_ctx, ast::ZBA_RTYPEUW((zreg, rsd, rsd, bropw_zba::ADDUW)))
        }}
        ast::C_NOT(rsdc) => {{
            let r = creg2reg_idx(rsdc);
            {
                let var_40 = !(rX_bits(core_ctx, r));
                wX_bits(core_ctx, r, var_40)
            };
            RETIRE_SUCCESS
        }}
        ast::C_MUL((rsdc, rs2c)) => {{
            let rd = creg2reg_idx(rsdc);
            let rs = creg2reg_idx(rs2c);
            execute(core_ctx, ast::MUL((rs, rd, rd, mul_op {
                high: false,
                signed_rs1: true,
                signed_rs2: true
            })))
        }}
        ast::F_BIN_RM_TYPE_H((rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_BIN_RM_TYPE_H'")}
        ast::F_MADD_TYPE_H((rs3, rs2, rs1, rm, rd, op)) => {todo!("Unsupported: 'F_MADD_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJ_H)) => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJN_H)) => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FSGNJX_H)) => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMIN_H)) => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_F_TYPE_H((rs2, rs1, rd, f_bin_f_op_H::FMAX_H)) => {todo!("Unsupported: 'F_BIN_F_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FEQ_H)) => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLT_H)) => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_BIN_X_TYPE_H((rs2, rs1, rd, f_bin_x_op_H::FLE_H)) => {todo!("Unsupported: 'F_BIN_X_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FSQRT_H)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_W_H)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_WU_H)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_W)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_WU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_S)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_H_D)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_S_H)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FF_TYPE_H((rs1, rm, rd, f_un_rm_ff_op_H::FCVT_D_H)) => {todo!("Unsupported: 'F_UN_RM_FF_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_L_H)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_FX_TYPE_H((rs1, rm, rd, f_un_rm_fx_op_H::FCVT_LU_H)) => {todo!("Unsupported: 'F_UN_RM_FX_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_L)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_RM_XF_TYPE_H((rs1, rm, rd, f_un_rm_xf_op_H::FCVT_H_LU)) => {todo!("Unsupported: 'F_UN_RM_XF_TYPE_H'")}
        ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FCLASS_H)) => {todo!("Unsupported: 'F_UN_X_TYPE_H'")}
        ast::F_UN_X_TYPE_H((rs1, rd, f_un_x_op_H::FMV_X_H)) => {todo!("Unsupported: 'F_UN_X_TYPE_H'")}
        ast::F_UN_F_TYPE_H((rs1, rd, f_un_f_op_H::FMV_H_X)) => {todo!("Unsupported: 'F_UN_F_TYPE_H'")}
        ast::FLI_H((constantidx, rd)) => {todo!("Unsupported: 'FLI_H'")}
        ast::FLI_S((constantidx, rd)) => {todo!("Unsupported: 'FLI_S'")}
        ast::FLI_D((constantidx, rd)) => {todo!("Unsupported: 'FLI_D'")}
        ast::FMINM_H((rs2, rs1, rd)) => {todo!("Unsupported: 'FMINM_H'")}
        ast::FMAXM_H((rs2, rs1, rd)) => {todo!("Unsupported: 'FMAXM_H'")}
        ast::FMINM_S((rs2, rs1, rd)) => {todo!("Unsupported: 'FMINM_S'")}
        ast::FMAXM_S((rs2, rs1, rd)) => {todo!("Unsupported: 'FMAXM_S'")}
        ast::FMINM_D((rs2, rs1, rd)) => {todo!("Unsupported: 'FMINM_D'")}
        ast::FMAXM_D((rs2, rs1, rd)) => {todo!("Unsupported: 'FMAXM_D'")}
        ast::FROUND_H((rs1, rm, rd)) => {todo!("Unsupported: 'FROUND_H'")}
        ast::FROUNDNX_H((rs1, rm, rd)) => {todo!("Unsupported: 'FROUNDNX_H'")}
        ast::FROUND_S((rs1, rm, rd)) => {todo!("Unsupported: 'FROUND_S'")}
        ast::FROUNDNX_S((rs1, rm, rd)) => {todo!("Unsupported: 'FROUNDNX_S'")}
        ast::FROUND_D((rs1, rm, rd)) => {todo!("Unsupported: 'FROUND_D'")}
        ast::FROUNDNX_D((rs1, rm, rd)) => {todo!("Unsupported: 'FROUNDNX_D'")}
        ast::FMVH_X_D((rs1, rd)) => {todo!("Unsupported: 'FMVH_X_D'")}
        ast::FMVP_D_X((rs2, rs1, rd)) => {todo!("Unsupported: 'FMVP_D_X'")}
        ast::FLEQ_H((rs2, rs1, rd)) => {todo!("Unsupported: 'FLEQ_H'")}
        ast::FLTQ_H((rs2, rs1, rd)) => {todo!("Unsupported: 'FLTQ_H'")}
        ast::FLEQ_S((rs2, rs1, rd)) => {todo!("Unsupported: 'FLEQ_S'")}
        ast::FLTQ_S((rs2, rs1, rd)) => {todo!("Unsupported: 'FLTQ_S'")}
        ast::FLEQ_D((rs2, rs1, rd)) => {todo!("Unsupported: 'FLEQ_D'")}
        ast::FLTQ_D((rs2, rs1, rd)) => {todo!("Unsupported: 'FLTQ_D'")}
        ast::FCVTMOD_W_D((rs1, rd)) => {todo!("Unsupported: 'FCVTMOD_W_D'")}
        ast::SHA256SIG0((rs1, rd)) => {todo!("Unsupported: 'SHA256SIG0'")}
        ast::SHA256SIG1((rs1, rd)) => {todo!("Unsupported: 'SHA256SIG1'")}
        ast::SHA256SUM0((rs1, rd)) => {todo!("Unsupported: 'SHA256SUM0'")}
        ast::SHA256SUM1((rs1, rd)) => {todo!("Unsupported: 'SHA256SUM1'")}
        ast::AES32ESMI((bs, rs2, rs1, rd)) => {todo!("Unsupported: 'AES32ESMI'")}
        ast::AES32ESI((bs, rs2, rs1, rd)) => {todo!("Unsupported: 'AES32ESI'")}
        ast::AES32DSMI((bs, rs2, rs1, rd)) => {todo!("Unsupported: 'AES32DSMI'")}
        ast::AES32DSI((bs, rs2, rs1, rd)) => {todo!("Unsupported: 'AES32DSI'")}
        ast::SHA512SIG0H((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SIG0H'")}
        ast::SHA512SIG0L((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SIG0L'")}
        ast::SHA512SIG1H((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SIG1H'")}
        ast::SHA512SIG1L((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SIG1L'")}
        ast::SHA512SUM0R((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SUM0R'")}
        ast::SHA512SUM1R((rs2, rs1, rd)) => {todo!("Unsupported: 'SHA512SUM1R'")}
        ast::AES64KS1I((rnum, rs1, rd)) => {todo!("Unsupported: 'AES64KS1I'")}
        ast::AES64KS2((rs2, rs1, rd)) => {todo!("Unsupported: 'AES64KS2'")}
        ast::AES64IM((rs1, rd)) => {todo!("Unsupported: 'AES64IM'")}
        ast::AES64ESM((rs2, rs1, rd)) => {todo!("Unsupported: 'AES64ESM'")}
        ast::AES64ES((rs2, rs1, rd)) => {todo!("Unsupported: 'AES64ES'")}
        ast::AES64DSM((rs2, rs1, rd)) => {todo!("Unsupported: 'AES64DSM'")}
        ast::AES64DS((rs2, rs1, rd)) => {todo!("Unsupported: 'AES64DS'")}
        ast::SHA512SIG0((rs1, rd)) => {todo!("Unsupported: 'SHA512SIG0'")}
        ast::SHA512SIG1((rs1, rd)) => {todo!("Unsupported: 'SHA512SIG1'")}
        ast::SHA512SUM0((rs1, rd)) => {todo!("Unsupported: 'SHA512SUM0'")}
        ast::SHA512SUM1((rs1, rd)) => {todo!("Unsupported: 'SHA512SUM1'")}
        ast::SM3P0((rs1, rd)) => {{
            let r1: BitVector<32> = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let result: BitVector<32> = (r1 ^ (rotatel(r1, 9) ^ rotatel(r1, 17)));
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::SM3P1((rs1, rd)) => {{
            let r1: BitVector<32> = subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0);
            let result: BitVector<32> = (r1 ^ (rotatel(r1, 15) ^ rotatel(r1, 23)));
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::SM4ED((bs, rs2, rs1, rd)) => {{
            let shamt: BitVector<5> = bitvector_concat::<2, 3, 5>(bs, BitVector::<3>::new(0b000));
            let sb_in: BitVector<8> = subrange_bits::<_, 8>(shift_bits_right(subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0), shamt), 7, 0);
            let x: BitVector<32> = bitvector_concat::<24, 8, 32>(BitVector::<24>::new(0b000000000000000000000000), sm4_sbox(sb_in));
            let y: BitVector<32> = (x ^ ((x << 8) ^ ((x << 2) ^ ((x << 18) ^ (((x & BitVector::<32>::new(0b00000000000000000000000000111111)) << 26) ^ ((x & BitVector::<32>::new(0b00000000000000000000000011000000)) << 10))))));
            let z: BitVector<32> = rotate_bits_left(y, shamt);
            let result: BitVector<32> = (z ^ subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0));
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::SM4KS((bs, rs2, rs1, rd)) => {{
            let shamt: BitVector<5> = bitvector_concat::<2, 3, 5>(bs, BitVector::<3>::new(0b000));
            let sb_in: BitVector<8> = subrange_bits::<_, 8>(shift_bits_right(subrange_bits::<_, 32>(rX_bits(core_ctx, rs2), 31, 0), shamt), 7, 0);
            let x: BitVector<32> = bitvector_concat::<24, 8, 32>(BitVector::<24>::new(0b000000000000000000000000), sm4_sbox(sb_in));
            let y: BitVector<32> = (x ^ (((x & BitVector::<32>::new(0b00000000000000000000000000000111)) << 29) ^ (((x & BitVector::<32>::new(0b00000000000000000000000011111110)) << 7) ^ (((x & BitVector::<32>::new(0b00000000000000000000000000000001)) << 23) ^ ((x & BitVector::<32>::new(0b00000000000000000000000011111000)) << 13)))));
            let z: BitVector<32> = rotate_bits_left(y, shamt);
            let result: BitVector<32> = (z ^ subrange_bits::<_, 32>(rX_bits(core_ctx, rs1), 31, 0));
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::ZBKB_RTYPE((rs2, rs1, rd, op)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let result: xlenbits = match op {
                brop_zbkb::PACK => {bitvector_concat::<32, 32, 64>(rs2_val.subrange::<0, 32, 32>(), rs1_val.subrange::<0, 32, 32>())}
                brop_zbkb::PACKH => {bitvector_concat::<8, 8, 16>(rs2_val.subrange::<0, 8, 8>(), rs1_val.subrange::<0, 8, 8>()).zero_extend::<64>()}
                _ => {panic!("Unreachable code")}
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::ZBKB_PACKW((rs2, rs1, rd)) => {{
            assert!(true, "riscv_insts_zbkb.sail:50.19-50.20");
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let result: BitVector<32> = bitvector_concat::<16, 16, 32>(rs2_val.subrange::<0, 16, 16>(), rs1_val.subrange::<0, 16, 16>());
            wX_bits(core_ctx, rd, sign_extend(64, result));
            RETIRE_SUCCESS
        }}
        ast::ZIP((rs1, rd)) => {{
            assert!(false, "riscv_insts_zbkb.sail:69.19-69.20");
            panic!("exit")
        }}
        ast::UNZIP((rs1, rd)) => {{
            assert!(false, "riscv_insts_zbkb.sail:91.19-91.20");
            panic!("exit")
        }}
        ast::BREV8((rs1, rd)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let mut result: xlenbits = zeros::<64>(64);
            {
                todo!("E_for");
                wX_bits(core_ctx, rd, result);
                RETIRE_SUCCESS
            }
        }}
        ast::XPERM8((rs2, rs1, rd)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let mut result: xlenbits = zeros::<64>(64);
            {
                todo!("E_for");
                wX_bits(core_ctx, rd, result);
                RETIRE_SUCCESS
            }
        }}
        ast::XPERM4((rs2, rs1, rd)) => {{
            let rs1_val = rX_bits(core_ctx, rs1);
            let rs2_val = rX_bits(core_ctx, rs2);
            let mut result: xlenbits = zeros::<64>(64);
            {
                todo!("E_for");
                wX_bits(core_ctx, rd, result);
                RETIRE_SUCCESS
            }
        }}
        ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_EQZ)) => {{
            let value = rX_bits(core_ctx, rs1);
            let condition = rX_bits(core_ctx, rs2);
            let result: xlenbits = if {(condition == zeros::<64>(64))} {
                zeros::<64>(64)
            } else {
                value
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::ZICOND_RTYPE((rs2, rs1, rd, zicondop::CZERO_NEZ)) => {{
            let value = rX_bits(core_ctx, rs1);
            let condition = rX_bits(core_ctx, rs2);
            let result: xlenbits = if {(condition != zeros::<64>(64))} {
                zeros::<64>(64)
            } else {
                value
            };
            wX_bits(core_ctx, rd, result);
            RETIRE_SUCCESS
        }}
        ast::VSETVLI((ma, ta, sew, lmul, rs1, rd)) => {todo!("Unsupported: 'VSETVLI'")}
        ast::VSETVL((rs2, rs1, rd)) => {todo!("Unsupported: 'VSETVL'")}
        ast::VSETIVLI((ma, ta, sew, lmul, uimm, rd)) => {todo!("Unsupported: 'VSETIVLI'")}
        ast::VVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'VVTYPE'")}
        ast::NVSTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'NVSTYPE'")}
        ast::NVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'NVTYPE'")}
        ast::MASKTYPEV((vs2, vs1, vd)) => {todo!("Unsupported: 'MASKTYPEV'")}
        ast::MOVETYPEV((vs1, vd)) => {todo!("Unsupported: 'MOVETYPEV'")}
        ast::VXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VXTYPE'")}
        ast::NXSTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'NXSTYPE'")}
        ast::NXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'NXTYPE'")}
        ast::VXSG((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VXSG'")}
        ast::MASKTYPEX((vs2, rs1, vd)) => {todo!("Unsupported: 'MASKTYPEX'")}
        ast::MOVETYPEX((rs1, vd)) => {todo!("Unsupported: 'MOVETYPEX'")}
        ast::VITYPE((funct6, vm, vs2, simm, vd)) => {todo!("Unsupported: 'VITYPE'")}
        ast::NISTYPE((funct6, vm, vs2, simm, vd)) => {todo!("Unsupported: 'NISTYPE'")}
        ast::NITYPE((funct6, vm, vs2, simm, vd)) => {todo!("Unsupported: 'NITYPE'")}
        ast::VISG((funct6, vm, vs2, simm, vd)) => {todo!("Unsupported: 'VISG'")}
        ast::MASKTYPEI((vs2, simm, vd)) => {todo!("Unsupported: 'MASKTYPEI'")}
        ast::MOVETYPEI((vd, simm)) => {todo!("Unsupported: 'MOVETYPEI'")}
        ast::VMVRTYPE((vs2, simm, vd)) => {todo!("Unsupported: 'VMVRTYPE'")}
        ast::MVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'MVVTYPE'")}
        ast::MVVMATYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'MVVMATYPE'")}
        ast::WVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'WVVTYPE'")}
        ast::WVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'WVTYPE'")}
        ast::WMVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'WMVVTYPE'")}
        ast::VEXT2TYPE((funct6, vm, vs2, vd)) => {todo!("Unsupported: 'VEXT2TYPE'")}
        ast::VEXT4TYPE((funct6, vm, vs2, vd)) => {todo!("Unsupported: 'VEXT4TYPE'")}
        ast::VEXT8TYPE((funct6, vm, vs2, vd)) => {todo!("Unsupported: 'VEXT8TYPE'")}
        ast::VMVXS((vs2, rd)) => {todo!("Unsupported: 'VMVXS'")}
        ast::MVVCOMPRESS((vs2, vs1, vd)) => {todo!("Unsupported: 'MVVCOMPRESS'")}
        ast::MVXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'MVXTYPE'")}
        ast::MVXMATYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'MVXMATYPE'")}
        ast::WVXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'WVXTYPE'")}
        ast::WXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'WXTYPE'")}
        ast::WMVXTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'WMVXTYPE'")}
        ast::VMVSX((rs1, vd)) => {todo!("Unsupported: 'VMVSX'")}
        ast::FVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'FVVTYPE'")}
        ast::FVVMATYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'FVVMATYPE'")}
        ast::FWVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'FWVVTYPE'")}
        ast::FWVVMATYPE((funct6, vm, vs1, vs2, vd)) => {todo!("Unsupported: 'FWVVMATYPE'")}
        ast::FWVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'FWVTYPE'")}
        ast::VFUNARY0((vm, vs2, vfunary0, vd)) => {todo!("Unsupported: 'VFUNARY0'")}
        ast::VFWUNARY0((vm, vs2, vfwunary0, vd)) => {todo!("Unsupported: 'VFWUNARY0'")}
        ast::VFNUNARY0((vm, vs2, vfnunary0, vd)) => {todo!("Unsupported: 'VFNUNARY0'")}
        ast::VFUNARY1((vm, vs2, vfunary1, vd)) => {todo!("Unsupported: 'VFUNARY1'")}
        ast::VFMVFS((vs2, rd)) => {todo!("Unsupported: 'VFMVFS'")}
        ast::FVFTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'FVFTYPE'")}
        ast::FVFMATYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'FVFMATYPE'")}
        ast::FWVFTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'FWVFTYPE'")}
        ast::FWVFMATYPE((funct6, vm, rs1, vs2, vd)) => {todo!("Unsupported: 'FWVFMATYPE'")}
        ast::FWFTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'FWFTYPE'")}
        ast::VFMERGE((vs2, rs1, vd)) => {todo!("Unsupported: 'VFMERGE'")}
        ast::VFMV((rs1, vd)) => {todo!("Unsupported: 'VFMV'")}
        ast::VFMVSF((rs1, vd)) => {todo!("Unsupported: 'VFMVSF'")}
        ast::VLSEGTYPE((nf, vm, rs1, width, vd)) => {todo!("Unsupported: 'VLSEGTYPE'")}
        ast::VLSEGFFTYPE((nf, vm, rs1, width, vd)) => {todo!("Unsupported: 'VLSEGFFTYPE'")}
        ast::VSSEGTYPE((nf, vm, rs1, width, vs3)) => {todo!("Unsupported: 'VSSEGTYPE'")}
        ast::VLSSEGTYPE((nf, vm, rs2, rs1, width, vd)) => {todo!("Unsupported: 'VLSSEGTYPE'")}
        ast::VSSSEGTYPE((nf, vm, rs2, rs1, width, vs3)) => {todo!("Unsupported: 'VSSSEGTYPE'")}
        ast::VLUXSEGTYPE((nf, vm, vs2, rs1, width, vd)) => {todo!("Unsupported: 'VLUXSEGTYPE'")}
        ast::VLOXSEGTYPE((nf, vm, vs2, rs1, width, vd)) => {todo!("Unsupported: 'VLOXSEGTYPE'")}
        ast::VSUXSEGTYPE((nf, vm, vs2, rs1, width, vs3)) => {todo!("Unsupported: 'VSUXSEGTYPE'")}
        ast::VSOXSEGTYPE((nf, vm, vs2, rs1, width, vs3)) => {todo!("Unsupported: 'VSOXSEGTYPE'")}
        ast::VLRETYPE((nf, rs1, width, vd)) => {todo!("Unsupported: 'VLRETYPE'")}
        ast::VSRETYPE((nf, rs1, vs3)) => {todo!("Unsupported: 'VSRETYPE'")}
        ast::VMTYPE((rs1, vd_or_vs3, op)) => {todo!("Unsupported: 'VMTYPE'")}
        ast::MMTYPE((funct6, vs2, vs1, vd)) => {todo!("Unsupported: 'MMTYPE'")}
        ast::VCPOP_M((vm, vs2, rd)) => {todo!("Unsupported: 'VCPOP_M'")}
        ast::VFIRST_M((vm, vs2, rd)) => {todo!("Unsupported: 'VFIRST_M'")}
        ast::VMSBF_M((vm, vs2, vd)) => {todo!("Unsupported: 'VMSBF_M'")}
        ast::VMSIF_M((vm, vs2, vd)) => {todo!("Unsupported: 'VMSIF_M'")}
        ast::VMSOF_M((vm, vs2, vd)) => {todo!("Unsupported: 'VMSOF_M'")}
        ast::VIOTA_M((vm, vs2, vd)) => {todo!("Unsupported: 'VIOTA_M'")}
        ast::VID_V((vm, vd)) => {todo!("Unsupported: 'VID_V'")}
        ast::VVMTYPE((funct6, vs2, vs1, vd)) => {todo!("Unsupported: 'VVMTYPE'")}
        ast::VVMCTYPE((funct6, vs2, vs1, vd)) => {todo!("Unsupported: 'VVMCTYPE'")}
        ast::VVMSTYPE((funct6, vs2, vs1, vd)) => {todo!("Unsupported: 'VVMSTYPE'")}
        ast::VVCMPTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'VVCMPTYPE'")}
        ast::VXMTYPE((funct6, vs2, rs1, vd)) => {todo!("Unsupported: 'VXMTYPE'")}
        ast::VXMCTYPE((funct6, vs2, rs1, vd)) => {todo!("Unsupported: 'VXMCTYPE'")}
        ast::VXMSTYPE((funct6, vs2, rs1, vd)) => {todo!("Unsupported: 'VXMSTYPE'")}
        ast::VXCMPTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VXCMPTYPE'")}
        ast::VIMTYPE((funct6, vs2, simm, vd)) => {todo!("Unsupported: 'VIMTYPE'")}
        ast::VIMCTYPE((funct6, vs2, simm, vd)) => {todo!("Unsupported: 'VIMCTYPE'")}
        ast::VIMSTYPE((funct6, vs2, simm, vd)) => {todo!("Unsupported: 'VIMSTYPE'")}
        ast::VICMPTYPE((funct6, vm, vs2, simm, vd)) => {todo!("Unsupported: 'VICMPTYPE'")}
        ast::FVVMTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'FVVMTYPE'")}
        ast::FVFMTYPE((funct6, vm, vs2, rs1, vd)) => {todo!("Unsupported: 'FVFMTYPE'")}
        ast::RIVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'RIVVTYPE'")}
        ast::RMVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'RMVVTYPE'")}
        ast::RFVVTYPE((funct6, vm, vs2, vs1, vd)) => {todo!("Unsupported: 'RFVVTYPE'")}
        ast::ZICBOM((cbop_zicbom::CBO_CLEAN, rs1)) => {if {{
            let var_41 = core_ctx.cur_privilege;
            cbo_clean_flush_enabled(core_ctx, var_41)
        }} {
            process_clean_inval(core_ctx, rs1, cbop_zicbom::CBO_CLEAN)
        } else {
            ExecutionResult::Illegal_Instruction(())
        }}
        ast::ZICBOM((cbop_zicbom::CBO_FLUSH, rs1)) => {if {{
            let var_42 = core_ctx.cur_privilege;
            cbo_clean_flush_enabled(core_ctx, var_42)
        }} {
            process_clean_inval(core_ctx, rs1, cbop_zicbom::CBO_FLUSH)
        } else {
            ExecutionResult::Illegal_Instruction(())
        }}
        ast::ZICBOM((cbop_zicbom::CBO_INVAL, rs1)) => {match {
            let var_43 = core_ctx.cur_privilege;
            cbop_priv_check(core_ctx, var_43)
        } {
            checked_cbop::CBOP_ILLEGAL => {ExecutionResult::Illegal_Instruction(())}
            checked_cbop::CBOP_ILLEGAL_VIRTUAL => {panic!("{}, l {}: {}", "riscv_insts_zicbom.sail", 151, "unimplemented")}
            checked_cbop::CBOP_INVAL_INVAL => {process_clean_inval(core_ctx, rs1, cbop_zicbom::CBO_INVAL)}
            checked_cbop::CBOP_INVAL_FLUSH => {process_clean_inval(core_ctx, rs1, cbop_zicbom::CBO_FLUSH)}
            _ => {panic!("Unreachable code")}
        }}
        ast::ZICBOZ(rs1) => {todo!("Unsupported: 'ZICBOZ'")}
        ast::VANDN_VV((vm, vs1, vs2, vd)) => {todo!("Unsupported: 'VANDN_VV'")}
        ast::VANDN_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VANDN_VX'")}
        ast::VBREV_V((vm, vs2, vd)) => {todo!("Unsupported: 'VBREV_V'")}
        ast::VBREV8_V((vm, vs2, vd)) => {todo!("Unsupported: 'VBREV8_V'")}
        ast::VREV8_V((vm, vs2, vd)) => {todo!("Unsupported: 'VREV8_V'")}
        ast::VCLZ_V((vm, vs2, vd)) => {todo!("Unsupported: 'VCLZ_V'")}
        ast::VCTZ_V((vm, vs2, vd)) => {todo!("Unsupported: 'VCTZ_V'")}
        ast::VCPOP_V((vm, vs2, vd)) => {todo!("Unsupported: 'VCPOP_V'")}
        ast::VROL_VV((vm, vs1, vs2, vd)) => {todo!("Unsupported: 'VROL_VV'")}
        ast::VROL_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VROL_VX'")}
        ast::VROR_VV((vm, vs1, vs2, vd)) => {todo!("Unsupported: 'VROR_VV'")}
        ast::VROR_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VROR_VX'")}
        ast::VROR_VI((vm, vs2, uimm, vd)) => {todo!("Unsupported: 'VROR_VI'")}
        ast::VWSLL_VV((vm, vs2, vs1, vd)) => {todo!("Unsupported: 'VWSLL_VV'")}
        ast::VWSLL_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VWSLL_VX'")}
        ast::VWSLL_VI((vm, vs2, uimm, vd)) => {todo!("Unsupported: 'VWSLL_VI'")}
        ast::VCLMUL_VV((vm, vs2, vs1, vd)) => {todo!("Unsupported: 'VCLMUL_VV'")}
        ast::VCLMUL_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VCLMUL_VX'")}
        ast::VCLMULH_VV((vm, vs2, vs1, vd)) => {todo!("Unsupported: 'VCLMULH_VV'")}
        ast::VCLMULH_VX((vm, vs2, rs1, vd)) => {todo!("Unsupported: 'VCLMULH_VX'")}
        ast::VSHA2MS_VV((vs2, vs1, vd)) => {todo!("Unsupported: 'VSHA2MS_VV'")}
        ast::ZVKSHA2TYPE((funct6, vs2, vs1, vd)) => {todo!("Unsupported: 'ZVKSHA2TYPE'")}
        ast::VSM3ME_VV((vs2, vs1, vd)) => {todo!("Unsupported: 'VSM3ME_VV'")}
        ast::VSM3C_VI((vs2, uimm, vd)) => {todo!("Unsupported: 'VSM3C_VI'")}
        ast::ZIMOP_MOP_R((mop, rs1, rd)) => {{
            wX_bits(core_ctx, rd, zeros::<64>(64));
            RETIRE_SUCCESS
        }}
        ast::ZIMOP_MOP_RR((mop, rs2, rs1, rd)) => {{
            wX_bits(core_ctx, rd, zeros::<64>(64));
            RETIRE_SUCCESS
        }}
        ast::ZCMOP(mop) => {{
            RETIRE_SUCCESS
        }}
        ast::JALR((imm, rs1, rd)) => {{
            let t: xlenbits = rX_bits(core_ctx, rs1).wrapped_add(sign_extend(64, imm));
            match ext_control_check_addr(t) {
                Ext_ControlAddr_Check::Ext_ControlAddr_Error(e) => {ExecutionResult::Ext_ControlAddr_Check_Failure(e)}
                Ext_ControlAddr_Check::Ext_ControlAddr_OK(addr) => {{
                    let target = bitvector_update(bits_of_virtaddr(addr), 0, false);
                    if {(bit_to_bool(bitvector_access(target, 1)) && !(currentlyEnabled(core_ctx, extension::Ext_Zca)))} {
                        ExecutionResult::Memory_Exception((addr, ExceptionType::E_Fetch_Addr_Align(())))
                    } else {
                        {
                            let var_44 = get_next_pc(core_ctx, ());
                            wX_bits(core_ctx, rd, var_44)
                        };
                        set_next_pc(core_ctx, target);
                        RETIRE_SUCCESS
                    }
                }}
                _ => {panic!("Unreachable code")}
            }
        }}
        ast::ILLEGAL(s) => {ExecutionResult::Illegal_Instruction(())}
        ast::C_ILLEGAL(s) => {ExecutionResult::Illegal_Instruction(())}
        _ => {panic!("Unreachable code")}
    }
}

/// csr_name_map_backwards_matches
/// 
/// Generated from the Sail sources.
pub fn csr_name_map_backwards_matches(arg_hashtag_: &'static str) -> bool {
    let head_exp_hashtag_ = arg_hashtag_;
    match match head_exp_hashtag_ {
        "misa" => {Some(true)}
        "mstatus" => {Some(true)}
        "menvcfg" => {Some(true)}
        "menvcfgh" => {Some(true)}
        "senvcfg" => {Some(true)}
        "mie" => {Some(true)}
        "mip" => {Some(true)}
        "medeleg" => {Some(true)}
        "medelegh" => {Some(true)}
        "mideleg" => {Some(true)}
        "mcause" => {Some(true)}
        "mtval" => {Some(true)}
        "mscratch" => {Some(true)}
        "scounteren" => {Some(true)}
        "mcounteren" => {Some(true)}
        "mcountinhibit" => {Some(true)}
        "mvendorid" => {Some(true)}
        "marchid" => {Some(true)}
        "mimpid" => {Some(true)}
        "mhartid" => {Some(true)}
        "mconfigptr" => {Some(true)}
        "sstatus" => {Some(true)}
        "sip" => {Some(true)}
        "sie" => {Some(true)}
        "sscratch" => {Some(true)}
        "scause" => {Some(true)}
        "stval" => {Some(true)}
        "tselect" => {Some(true)}
        "tdata1" => {Some(true)}
        "tdata2" => {Some(true)}
        "tdata3" => {Some(true)}
        "pmpcfg0" => {Some(true)}
        "pmpcfg1" => {Some(true)}
        "pmpcfg2" => {Some(true)}
        "pmpcfg3" => {Some(true)}
        "pmpcfg4" => {Some(true)}
        "pmpcfg5" => {Some(true)}
        "pmpcfg6" => {Some(true)}
        "pmpcfg7" => {Some(true)}
        "pmpcfg8" => {Some(true)}
        "pmpcfg9" => {Some(true)}
        "pmpcfg10" => {Some(true)}
        "pmpcfg11" => {Some(true)}
        "pmpcfg12" => {Some(true)}
        "pmpcfg13" => {Some(true)}
        "pmpcfg14" => {Some(true)}
        "pmpcfg15" => {Some(true)}
        "pmpaddr0" => {Some(true)}
        "pmpaddr1" => {Some(true)}
        "pmpaddr2" => {Some(true)}
        "pmpaddr3" => {Some(true)}
        "pmpaddr4" => {Some(true)}
        "pmpaddr5" => {Some(true)}
        "pmpaddr6" => {Some(true)}
        "pmpaddr7" => {Some(true)}
        "pmpaddr8" => {Some(true)}
        "pmpaddr9" => {Some(true)}
        "pmpaddr10" => {Some(true)}
        "pmpaddr11" => {Some(true)}
        "pmpaddr12" => {Some(true)}
        "pmpaddr13" => {Some(true)}
        "pmpaddr14" => {Some(true)}
        "pmpaddr15" => {Some(true)}
        "pmpaddr16" => {Some(true)}
        "pmpaddr17" => {Some(true)}
        "pmpaddr18" => {Some(true)}
        "pmpaddr19" => {Some(true)}
        "pmpaddr20" => {Some(true)}
        "pmpaddr21" => {Some(true)}
        "pmpaddr22" => {Some(true)}
        "pmpaddr23" => {Some(true)}
        "pmpaddr24" => {Some(true)}
        "pmpaddr25" => {Some(true)}
        "pmpaddr26" => {Some(true)}
        "pmpaddr27" => {Some(true)}
        "pmpaddr28" => {Some(true)}
        "pmpaddr29" => {Some(true)}
        "pmpaddr30" => {Some(true)}
        "pmpaddr31" => {Some(true)}
        "pmpaddr32" => {Some(true)}
        "pmpaddr33" => {Some(true)}
        "pmpaddr34" => {Some(true)}
        "pmpaddr35" => {Some(true)}
        "pmpaddr36" => {Some(true)}
        "pmpaddr37" => {Some(true)}
        "pmpaddr38" => {Some(true)}
        "pmpaddr39" => {Some(true)}
        "pmpaddr40" => {Some(true)}
        "pmpaddr41" => {Some(true)}
        "pmpaddr42" => {Some(true)}
        "pmpaddr43" => {Some(true)}
        "pmpaddr44" => {Some(true)}
        "pmpaddr45" => {Some(true)}
        "pmpaddr46" => {Some(true)}
        "pmpaddr47" => {Some(true)}
        "pmpaddr48" => {Some(true)}
        "pmpaddr49" => {Some(true)}
        "pmpaddr50" => {Some(true)}
        "pmpaddr51" => {Some(true)}
        "pmpaddr52" => {Some(true)}
        "pmpaddr53" => {Some(true)}
        "pmpaddr54" => {Some(true)}
        "pmpaddr55" => {Some(true)}
        "pmpaddr56" => {Some(true)}
        "pmpaddr57" => {Some(true)}
        "pmpaddr58" => {Some(true)}
        "pmpaddr59" => {Some(true)}
        "pmpaddr60" => {Some(true)}
        "pmpaddr61" => {Some(true)}
        "pmpaddr62" => {Some(true)}
        "pmpaddr63" => {Some(true)}
        "vstart" => {Some(true)}
        "vxsat" => {Some(true)}
        "vxrm" => {Some(true)}
        "vcsr" => {Some(true)}
        "vl" => {Some(true)}
        "vtype" => {Some(true)}
        "vlenb" => {Some(true)}
        "stvec" => {Some(true)}
        "sepc" => {Some(true)}
        "mtvec" => {Some(true)}
        "mepc" => {Some(true)}
        "hpmcounter3" => {Some(true)}
        "hpmcounter4" => {Some(true)}
        "hpmcounter5" => {Some(true)}
        "hpmcounter6" => {Some(true)}
        "hpmcounter7" => {Some(true)}
        "hpmcounter8" => {Some(true)}
        "hpmcounter9" => {Some(true)}
        "hpmcounter10" => {Some(true)}
        "hpmcounter11" => {Some(true)}
        "hpmcounter12" => {Some(true)}
        "hpmcounter13" => {Some(true)}
        "hpmcounter14" => {Some(true)}
        "hpmcounter15" => {Some(true)}
        "hpmcounter16" => {Some(true)}
        "hpmcounter17" => {Some(true)}
        "hpmcounter18" => {Some(true)}
        "hpmcounter19" => {Some(true)}
        "hpmcounter20" => {Some(true)}
        "hpmcounter21" => {Some(true)}
        "hpmcounter22" => {Some(true)}
        "hpmcounter23" => {Some(true)}
        "hpmcounter24" => {Some(true)}
        "hpmcounter25" => {Some(true)}
        "hpmcounter26" => {Some(true)}
        "hpmcounter27" => {Some(true)}
        "hpmcounter28" => {Some(true)}
        "hpmcounter29" => {Some(true)}
        "hpmcounter30" => {Some(true)}
        "hpmcounter31" => {Some(true)}
        "hpmcounter3h" => {Some(true)}
        "hpmcounter4h" => {Some(true)}
        "hpmcounter5h" => {Some(true)}
        "hpmcounter6h" => {Some(true)}
        "hpmcounter7h" => {Some(true)}
        "hpmcounter8h" => {Some(true)}
        "hpmcounter9h" => {Some(true)}
        "hpmcounter10h" => {Some(true)}
        "hpmcounter11h" => {Some(true)}
        "hpmcounter12h" => {Some(true)}
        "hpmcounter13h" => {Some(true)}
        "hpmcounter14h" => {Some(true)}
        "hpmcounter15h" => {Some(true)}
        "hpmcounter16h" => {Some(true)}
        "hpmcounter17h" => {Some(true)}
        "hpmcounter18h" => {Some(true)}
        "hpmcounter19h" => {Some(true)}
        "hpmcounter20h" => {Some(true)}
        "hpmcounter21h" => {Some(true)}
        "hpmcounter22h" => {Some(true)}
        "hpmcounter23h" => {Some(true)}
        "hpmcounter24h" => {Some(true)}
        "hpmcounter25h" => {Some(true)}
        "hpmcounter26h" => {Some(true)}
        "hpmcounter27h" => {Some(true)}
        "hpmcounter28h" => {Some(true)}
        "hpmcounter29h" => {Some(true)}
        "hpmcounter30h" => {Some(true)}
        "hpmcounter31h" => {Some(true)}
        "mhpmevent3" => {Some(true)}
        "mhpmevent4" => {Some(true)}
        "mhpmevent5" => {Some(true)}
        "mhpmevent6" => {Some(true)}
        "mhpmevent7" => {Some(true)}
        "mhpmevent8" => {Some(true)}
        "mhpmevent9" => {Some(true)}
        "mhpmevent10" => {Some(true)}
        "mhpmevent11" => {Some(true)}
        "mhpmevent12" => {Some(true)}
        "mhpmevent13" => {Some(true)}
        "mhpmevent14" => {Some(true)}
        "mhpmevent15" => {Some(true)}
        "mhpmevent16" => {Some(true)}
        "mhpmevent17" => {Some(true)}
        "mhpmevent18" => {Some(true)}
        "mhpmevent19" => {Some(true)}
        "mhpmevent20" => {Some(true)}
        "mhpmevent21" => {Some(true)}
        "mhpmevent22" => {Some(true)}
        "mhpmevent23" => {Some(true)}
        "mhpmevent24" => {Some(true)}
        "mhpmevent25" => {Some(true)}
        "mhpmevent26" => {Some(true)}
        "mhpmevent27" => {Some(true)}
        "mhpmevent28" => {Some(true)}
        "mhpmevent29" => {Some(true)}
        "mhpmevent30" => {Some(true)}
        "mhpmevent31" => {Some(true)}
        "mhpmcounter3" => {Some(true)}
        "mhpmcounter4" => {Some(true)}
        "mhpmcounter5" => {Some(true)}
        "mhpmcounter6" => {Some(true)}
        "mhpmcounter7" => {Some(true)}
        "mhpmcounter8" => {Some(true)}
        "mhpmcounter9" => {Some(true)}
        "mhpmcounter10" => {Some(true)}
        "mhpmcounter11" => {Some(true)}
        "mhpmcounter12" => {Some(true)}
        "mhpmcounter13" => {Some(true)}
        "mhpmcounter14" => {Some(true)}
        "mhpmcounter15" => {Some(true)}
        "mhpmcounter16" => {Some(true)}
        "mhpmcounter17" => {Some(true)}
        "mhpmcounter18" => {Some(true)}
        "mhpmcounter19" => {Some(true)}
        "mhpmcounter20" => {Some(true)}
        "mhpmcounter21" => {Some(true)}
        "mhpmcounter22" => {Some(true)}
        "mhpmcounter23" => {Some(true)}
        "mhpmcounter24" => {Some(true)}
        "mhpmcounter25" => {Some(true)}
        "mhpmcounter26" => {Some(true)}
        "mhpmcounter27" => {Some(true)}
        "mhpmcounter28" => {Some(true)}
        "mhpmcounter29" => {Some(true)}
        "mhpmcounter30" => {Some(true)}
        "mhpmcounter31" => {Some(true)}
        "mhpmcounter3h" => {Some(true)}
        "mhpmcounter4h" => {Some(true)}
        "mhpmcounter5h" => {Some(true)}
        "mhpmcounter6h" => {Some(true)}
        "mhpmcounter7h" => {Some(true)}
        "mhpmcounter8h" => {Some(true)}
        "mhpmcounter9h" => {Some(true)}
        "mhpmcounter10h" => {Some(true)}
        "mhpmcounter11h" => {Some(true)}
        "mhpmcounter12h" => {Some(true)}
        "mhpmcounter13h" => {Some(true)}
        "mhpmcounter14h" => {Some(true)}
        "mhpmcounter15h" => {Some(true)}
        "mhpmcounter16h" => {Some(true)}
        "mhpmcounter17h" => {Some(true)}
        "mhpmcounter18h" => {Some(true)}
        "mhpmcounter19h" => {Some(true)}
        "mhpmcounter20h" => {Some(true)}
        "mhpmcounter21h" => {Some(true)}
        "mhpmcounter22h" => {Some(true)}
        "mhpmcounter23h" => {Some(true)}
        "mhpmcounter24h" => {Some(true)}
        "mhpmcounter25h" => {Some(true)}
        "mhpmcounter26h" => {Some(true)}
        "mhpmcounter27h" => {Some(true)}
        "mhpmcounter28h" => {Some(true)}
        "mhpmcounter29h" => {Some(true)}
        "mhpmcounter30h" => {Some(true)}
        "mhpmcounter31h" => {Some(true)}
        "mhpmcounter3h" => {Some(true)}
        "mhpmcounter4h" => {Some(true)}
        "mhpmcounter5h" => {Some(true)}
        "mhpmcounter6h" => {Some(true)}
        "mhpmcounter7h" => {Some(true)}
        "mhpmcounter8h" => {Some(true)}
        "mhpmcounter9h" => {Some(true)}
        "mhpmcounter10h" => {Some(true)}
        "mhpmcounter11h" => {Some(true)}
        "mhpmcounter12h" => {Some(true)}
        "mhpmcounter13h" => {Some(true)}
        "mhpmcounter14h" => {Some(true)}
        "mhpmcounter15h" => {Some(true)}
        "mhpmcounter16h" => {Some(true)}
        "mhpmcounter17h" => {Some(true)}
        "mhpmcounter18h" => {Some(true)}
        "mhpmcounter19h" => {Some(true)}
        "mhpmcounter20h" => {Some(true)}
        "mhpmcounter21h" => {Some(true)}
        "mhpmcounter22h" => {Some(true)}
        "mhpmcounter23h" => {Some(true)}
        "mhpmcounter24h" => {Some(true)}
        "mhpmcounter25h" => {Some(true)}
        "mhpmcounter26h" => {Some(true)}
        "mhpmcounter27h" => {Some(true)}
        "mhpmcounter28h" => {Some(true)}
        "mhpmcounter29h" => {Some(true)}
        "mhpmcounter30h" => {Some(true)}
        "mhpmcounter31h" => {Some(true)}
        "scountovf" => {Some(true)}
        "seed" => {Some(true)}
        "cycle" => {Some(true)}
        "time" => {Some(true)}
        "instret" => {Some(true)}
        "cycleh" => {Some(true)}
        "timeh" => {Some(true)}
        "instreth" => {Some(true)}
        "mcycle" => {Some(true)}
        "minstret" => {Some(true)}
        "mcycleh" => {Some(true)}
        "minstreth" => {Some(true)}
        "fflags" => {Some(true)}
        "frm" => {Some(true)}
        "fcsr" => {Some(true)}
        "mcyclecfg" => {Some(true)}
        "mcyclecfgh" => {Some(true)}
        "minstretcfg" => {Some(true)}
        "minstretcfgh" => {Some(true)}
        "stimecmp" => {Some(true)}
        "stimecmph" => {Some(true)}
        "satp" => {Some(true)}
        mapping0_hashtag_ if {hex_bits_12_backwards_matches(mapping0_hashtag_)} => {match hex_bits_12_backwards(mapping0_hashtag_) {
            reg => {Some(true)}
            _ => {None}
            _ => {panic!("Unreachable code")}
        }}
        _ => {None}
        _ => {panic!("Unreachable code")}
    } {
        Some(result) => {result}
        None => {false}
        _ => {panic!("Unreachable code")}
    }
}

/// HartState
/// 
/// Generated from the Sail sources at `riscv_step_common.sail` L21-28.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum HartState {
    HART_ACTIVE(()),
    HART_WAITING(instbits)
}

/// FetchResult
/// 
/// Generated from the Sail sources at `riscv_step_common.sail` L48-53.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum FetchResult {
    F_Ext_Error(ext_fetch_addr_error),
    F_Base(word),
    F_RVC(half),
    F_Error((ExceptionType, xlenbits))
}

/// Step
/// 
/// Generated from the Sail sources at `riscv_step.sail` L13-19.
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub enum Step {
    Step_Pending_Interrupt((InterruptType, Privilege)),
    Step_Ext_Fetch_Failure(ext_fetch_addr_error),
    Step_Fetch_Failure((virtaddr, ExceptionType)),
    Step_Execute((ExecutionResult, instbits)),
    Step_Waiting(())
}