riscv-formal-nmigen/insns/isa_rv32i.py

# Generated by isa_rv32i_gen.py
from nmigen import *
from insn_lui import *
from insn_auipc import *
from insn_jal import *
from insn_jalr import *
from insn_beq import *
from insn_bne import *
from insn_blt import *
from insn_bge import *
from insn_bltu import *
from insn_bgeu import *
from insn_lb import *
from insn_lh import *
from insn_lw import *
from insn_lbu import *
from insn_lhu import *
from insn_sb import *
from insn_sh import *
from insn_sw import *
from insn_addi import *
from insn_slti import *
from insn_sltiu import *
from insn_xori import *
from insn_ori import *
from insn_andi import *
from insn_slli import *
from insn_srli import *
from insn_srai import *
from insn_add import *
from insn_sub import *
from insn_sll import *
from insn_slt import *
from insn_sltu import *
from insn_xor import *
from insn_srl import *
from insn_sra import *
from insn_or import *
from insn_and import *

class rvfi_isa_rv32i(Elaboratable):
    def __init__(self, RISCV_FORMAL_ILEN=32, RISCV_FORMAL_XLEN=32):
        self.RISCV_FORMAL_ILEN = RISCV_FORMAL_ILEN
        self.RISCV_FORMAL_XLEN = RISCV_FORMAL_XLEN
        self.rvfi_valid = Signal(1)
        self.rvfi_insn = Signal(self.RISCV_FORMAL_ILEN)
        self.rvfi_pc_rdata = Signal(self.RISCV_FORMAL_XLEN)
        self.rvfi_rs1_rdata = Signal(self.RISCV_FORMAL_XLEN)
        self.rvfi_rs2_rdata = Signal(self.RISCV_FORMAL_XLEN)
        self.rvfi_mem_rdata = Signal(self.RISCV_FORMAL_XLEN)

        self.spec_valid = Signal(1)
        self.spec_trap = Signal(1)
        self.spec_rs1_addr = Signal(5)
        self.spec_rs2_addr = Signal(5)
        self.spec_rd_addr = Signal(5)
        self.spec_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        self.spec_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        self.spec_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        self.spec_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        self.spec_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        self.spec_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
    def ports(self):
        input_ports = [
            self.rvfi_valid,
            self.rvfi_insn,
            self.rvfi_pc_rdata,
            self.rvfi_rs1_rdata,
            self.rvfi_rs2_rdata,
            self.rvfi_mem_rdata
        ]
        output_ports = [
            self.spec_valid,
            self.spec_trap,
            self.spec_rs1_addr,
            self.spec_rs2_addr,
            self.spec_rd_addr,
            self.spec_rd_wdata,
            self.spec_pc_wdata,
            self.spec_mem_addr,
            self.spec_mem_rmask,
            self.spec_mem_wmask,
            self.spec_mem_wdata
        ]
        return input_ports + output_ports
    def elaborate(self, platform):
        m = Module()

        spec_insn_lui_valid = Signal(1)
        spec_insn_lui_trap = Signal(1)
        spec_insn_lui_rs1_addr = Signal(5)
        spec_insn_lui_rs2_addr = Signal(5)
        spec_insn_lui_rd_addr = Signal(5)
        spec_insn_lui_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lui_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lui_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lui_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lui_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lui_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lui = insn_lui = rvfi_insn_lui()
        m.d.comb += insn_lui.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lui.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lui.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lui.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lui.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lui.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lui_valid.eq(insn_lui.spec_valid)
        m.d.comb += spec_insn_lui_trap.eq(insn_lui.spec_trap)
        m.d.comb += spec_insn_lui_rs1_addr.eq(insn_lui.spec_rs1_addr)
        m.d.comb += spec_insn_lui_rs2_addr.eq(insn_lui.spec_rs2_addr)
        m.d.comb += spec_insn_lui_rd_addr.eq(insn_lui.spec_rd_addr)
        m.d.comb += spec_insn_lui_rd_wdata.eq(insn_lui.spec_rd_wdata)
        m.d.comb += spec_insn_lui_pc_wdata.eq(insn_lui.spec_pc_wdata)
        m.d.comb += spec_insn_lui_mem_addr.eq(insn_lui.spec_mem_addr)
        m.d.comb += spec_insn_lui_mem_rmask.eq(insn_lui.spec_mem_rmask)
        m.d.comb += spec_insn_lui_mem_wmask.eq(insn_lui.spec_mem_wmask)
        m.d.comb += spec_insn_lui_mem_wdata.eq(insn_lui.spec_mem_wdata)

        spec_insn_auipc_valid = Signal(1)
        spec_insn_auipc_trap = Signal(1)
        spec_insn_auipc_rs1_addr = Signal(5)
        spec_insn_auipc_rs2_addr = Signal(5)
        spec_insn_auipc_rd_addr = Signal(5)
        spec_insn_auipc_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_auipc_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_auipc_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_auipc_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_auipc_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_auipc_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_auipc = insn_auipc = rvfi_insn_auipc()
        m.d.comb += insn_auipc.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_auipc.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_auipc.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_auipc.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_auipc.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_auipc.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_auipc_valid.eq(insn_auipc.spec_valid)
        m.d.comb += spec_insn_auipc_trap.eq(insn_auipc.spec_trap)
        m.d.comb += spec_insn_auipc_rs1_addr.eq(insn_auipc.spec_rs1_addr)
        m.d.comb += spec_insn_auipc_rs2_addr.eq(insn_auipc.spec_rs2_addr)
        m.d.comb += spec_insn_auipc_rd_addr.eq(insn_auipc.spec_rd_addr)
        m.d.comb += spec_insn_auipc_rd_wdata.eq(insn_auipc.spec_rd_wdata)
        m.d.comb += spec_insn_auipc_pc_wdata.eq(insn_auipc.spec_pc_wdata)
        m.d.comb += spec_insn_auipc_mem_addr.eq(insn_auipc.spec_mem_addr)
        m.d.comb += spec_insn_auipc_mem_rmask.eq(insn_auipc.spec_mem_rmask)
        m.d.comb += spec_insn_auipc_mem_wmask.eq(insn_auipc.spec_mem_wmask)
        m.d.comb += spec_insn_auipc_mem_wdata.eq(insn_auipc.spec_mem_wdata)

        spec_insn_jal_valid = Signal(1)
        spec_insn_jal_trap = Signal(1)
        spec_insn_jal_rs1_addr = Signal(5)
        spec_insn_jal_rs2_addr = Signal(5)
        spec_insn_jal_rd_addr = Signal(5)
        spec_insn_jal_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jal_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jal_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jal_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_jal_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_jal_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_jal = insn_jal = rvfi_insn_jal()
        m.d.comb += insn_jal.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_jal.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_jal.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_jal.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_jal.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_jal.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_jal_valid.eq(insn_jal.spec_valid)
        m.d.comb += spec_insn_jal_trap.eq(insn_jal.spec_trap)
        m.d.comb += spec_insn_jal_rs1_addr.eq(insn_jal.spec_rs1_addr)
        m.d.comb += spec_insn_jal_rs2_addr.eq(insn_jal.spec_rs2_addr)
        m.d.comb += spec_insn_jal_rd_addr.eq(insn_jal.spec_rd_addr)
        m.d.comb += spec_insn_jal_rd_wdata.eq(insn_jal.spec_rd_wdata)
        m.d.comb += spec_insn_jal_pc_wdata.eq(insn_jal.spec_pc_wdata)
        m.d.comb += spec_insn_jal_mem_addr.eq(insn_jal.spec_mem_addr)
        m.d.comb += spec_insn_jal_mem_rmask.eq(insn_jal.spec_mem_rmask)
        m.d.comb += spec_insn_jal_mem_wmask.eq(insn_jal.spec_mem_wmask)
        m.d.comb += spec_insn_jal_mem_wdata.eq(insn_jal.spec_mem_wdata)

        spec_insn_jalr_valid = Signal(1)
        spec_insn_jalr_trap = Signal(1)
        spec_insn_jalr_rs1_addr = Signal(5)
        spec_insn_jalr_rs2_addr = Signal(5)
        spec_insn_jalr_rd_addr = Signal(5)
        spec_insn_jalr_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jalr_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jalr_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_jalr_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_jalr_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_jalr_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_jalr = insn_jalr = rvfi_insn_jalr()
        m.d.comb += insn_jalr.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_jalr.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_jalr.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_jalr.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_jalr.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_jalr.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_jalr_valid.eq(insn_jalr.spec_valid)
        m.d.comb += spec_insn_jalr_trap.eq(insn_jalr.spec_trap)
        m.d.comb += spec_insn_jalr_rs1_addr.eq(insn_jalr.spec_rs1_addr)
        m.d.comb += spec_insn_jalr_rs2_addr.eq(insn_jalr.spec_rs2_addr)
        m.d.comb += spec_insn_jalr_rd_addr.eq(insn_jalr.spec_rd_addr)
        m.d.comb += spec_insn_jalr_rd_wdata.eq(insn_jalr.spec_rd_wdata)
        m.d.comb += spec_insn_jalr_pc_wdata.eq(insn_jalr.spec_pc_wdata)
        m.d.comb += spec_insn_jalr_mem_addr.eq(insn_jalr.spec_mem_addr)
        m.d.comb += spec_insn_jalr_mem_rmask.eq(insn_jalr.spec_mem_rmask)
        m.d.comb += spec_insn_jalr_mem_wmask.eq(insn_jalr.spec_mem_wmask)
        m.d.comb += spec_insn_jalr_mem_wdata.eq(insn_jalr.spec_mem_wdata)

        spec_insn_beq_valid = Signal(1)
        spec_insn_beq_trap = Signal(1)
        spec_insn_beq_rs1_addr = Signal(5)
        spec_insn_beq_rs2_addr = Signal(5)
        spec_insn_beq_rd_addr = Signal(5)
        spec_insn_beq_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_beq_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_beq_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_beq_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_beq_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_beq_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_beq = insn_beq = rvfi_insn_beq()
        m.d.comb += insn_beq.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_beq.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_beq.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_beq.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_beq.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_beq.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_beq_valid.eq(insn_beq.spec_valid)
        m.d.comb += spec_insn_beq_trap.eq(insn_beq.spec_trap)
        m.d.comb += spec_insn_beq_rs1_addr.eq(insn_beq.spec_rs1_addr)
        m.d.comb += spec_insn_beq_rs2_addr.eq(insn_beq.spec_rs2_addr)
        m.d.comb += spec_insn_beq_rd_addr.eq(insn_beq.spec_rd_addr)
        m.d.comb += spec_insn_beq_rd_wdata.eq(insn_beq.spec_rd_wdata)
        m.d.comb += spec_insn_beq_pc_wdata.eq(insn_beq.spec_pc_wdata)
        m.d.comb += spec_insn_beq_mem_addr.eq(insn_beq.spec_mem_addr)
        m.d.comb += spec_insn_beq_mem_rmask.eq(insn_beq.spec_mem_rmask)
        m.d.comb += spec_insn_beq_mem_wmask.eq(insn_beq.spec_mem_wmask)
        m.d.comb += spec_insn_beq_mem_wdata.eq(insn_beq.spec_mem_wdata)

        spec_insn_bne_valid = Signal(1)
        spec_insn_bne_trap = Signal(1)
        spec_insn_bne_rs1_addr = Signal(5)
        spec_insn_bne_rs2_addr = Signal(5)
        spec_insn_bne_rd_addr = Signal(5)
        spec_insn_bne_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bne_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bne_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bne_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bne_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bne_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_bne = insn_bne = rvfi_insn_bne()
        m.d.comb += insn_bne.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_bne.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_bne.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_bne.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_bne.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_bne.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_bne_valid.eq(insn_bne.spec_valid)
        m.d.comb += spec_insn_bne_trap.eq(insn_bne.spec_trap)
        m.d.comb += spec_insn_bne_rs1_addr.eq(insn_bne.spec_rs1_addr)
        m.d.comb += spec_insn_bne_rs2_addr.eq(insn_bne.spec_rs2_addr)
        m.d.comb += spec_insn_bne_rd_addr.eq(insn_bne.spec_rd_addr)
        m.d.comb += spec_insn_bne_rd_wdata.eq(insn_bne.spec_rd_wdata)
        m.d.comb += spec_insn_bne_pc_wdata.eq(insn_bne.spec_pc_wdata)
        m.d.comb += spec_insn_bne_mem_addr.eq(insn_bne.spec_mem_addr)
        m.d.comb += spec_insn_bne_mem_rmask.eq(insn_bne.spec_mem_rmask)
        m.d.comb += spec_insn_bne_mem_wmask.eq(insn_bne.spec_mem_wmask)
        m.d.comb += spec_insn_bne_mem_wdata.eq(insn_bne.spec_mem_wdata)

        spec_insn_blt_valid = Signal(1)
        spec_insn_blt_trap = Signal(1)
        spec_insn_blt_rs1_addr = Signal(5)
        spec_insn_blt_rs2_addr = Signal(5)
        spec_insn_blt_rd_addr = Signal(5)
        spec_insn_blt_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_blt_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_blt_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_blt_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_blt_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_blt_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_blt = insn_blt = rvfi_insn_blt()
        m.d.comb += insn_blt.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_blt.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_blt.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_blt.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_blt.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_blt.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_blt_valid.eq(insn_blt.spec_valid)
        m.d.comb += spec_insn_blt_trap.eq(insn_blt.spec_trap)
        m.d.comb += spec_insn_blt_rs1_addr.eq(insn_blt.spec_rs1_addr)
        m.d.comb += spec_insn_blt_rs2_addr.eq(insn_blt.spec_rs2_addr)
        m.d.comb += spec_insn_blt_rd_addr.eq(insn_blt.spec_rd_addr)
        m.d.comb += spec_insn_blt_rd_wdata.eq(insn_blt.spec_rd_wdata)
        m.d.comb += spec_insn_blt_pc_wdata.eq(insn_blt.spec_pc_wdata)
        m.d.comb += spec_insn_blt_mem_addr.eq(insn_blt.spec_mem_addr)
        m.d.comb += spec_insn_blt_mem_rmask.eq(insn_blt.spec_mem_rmask)
        m.d.comb += spec_insn_blt_mem_wmask.eq(insn_blt.spec_mem_wmask)
        m.d.comb += spec_insn_blt_mem_wdata.eq(insn_blt.spec_mem_wdata)

        spec_insn_bge_valid = Signal(1)
        spec_insn_bge_trap = Signal(1)
        spec_insn_bge_rs1_addr = Signal(5)
        spec_insn_bge_rs2_addr = Signal(5)
        spec_insn_bge_rd_addr = Signal(5)
        spec_insn_bge_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bge_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bge_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bge_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bge_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bge_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_bge = insn_bge = rvfi_insn_bge()
        m.d.comb += insn_bge.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_bge.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_bge.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_bge.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_bge.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_bge.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_bge_valid.eq(insn_bge.spec_valid)
        m.d.comb += spec_insn_bge_trap.eq(insn_bge.spec_trap)
        m.d.comb += spec_insn_bge_rs1_addr.eq(insn_bge.spec_rs1_addr)
        m.d.comb += spec_insn_bge_rs2_addr.eq(insn_bge.spec_rs2_addr)
        m.d.comb += spec_insn_bge_rd_addr.eq(insn_bge.spec_rd_addr)
        m.d.comb += spec_insn_bge_rd_wdata.eq(insn_bge.spec_rd_wdata)
        m.d.comb += spec_insn_bge_pc_wdata.eq(insn_bge.spec_pc_wdata)
        m.d.comb += spec_insn_bge_mem_addr.eq(insn_bge.spec_mem_addr)
        m.d.comb += spec_insn_bge_mem_rmask.eq(insn_bge.spec_mem_rmask)
        m.d.comb += spec_insn_bge_mem_wmask.eq(insn_bge.spec_mem_wmask)
        m.d.comb += spec_insn_bge_mem_wdata.eq(insn_bge.spec_mem_wdata)

        spec_insn_bltu_valid = Signal(1)
        spec_insn_bltu_trap = Signal(1)
        spec_insn_bltu_rs1_addr = Signal(5)
        spec_insn_bltu_rs2_addr = Signal(5)
        spec_insn_bltu_rd_addr = Signal(5)
        spec_insn_bltu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bltu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bltu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bltu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bltu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bltu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_bltu = insn_bltu = rvfi_insn_bltu()
        m.d.comb += insn_bltu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_bltu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_bltu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_bltu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_bltu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_bltu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_bltu_valid.eq(insn_bltu.spec_valid)
        m.d.comb += spec_insn_bltu_trap.eq(insn_bltu.spec_trap)
        m.d.comb += spec_insn_bltu_rs1_addr.eq(insn_bltu.spec_rs1_addr)
        m.d.comb += spec_insn_bltu_rs2_addr.eq(insn_bltu.spec_rs2_addr)
        m.d.comb += spec_insn_bltu_rd_addr.eq(insn_bltu.spec_rd_addr)
        m.d.comb += spec_insn_bltu_rd_wdata.eq(insn_bltu.spec_rd_wdata)
        m.d.comb += spec_insn_bltu_pc_wdata.eq(insn_bltu.spec_pc_wdata)
        m.d.comb += spec_insn_bltu_mem_addr.eq(insn_bltu.spec_mem_addr)
        m.d.comb += spec_insn_bltu_mem_rmask.eq(insn_bltu.spec_mem_rmask)
        m.d.comb += spec_insn_bltu_mem_wmask.eq(insn_bltu.spec_mem_wmask)
        m.d.comb += spec_insn_bltu_mem_wdata.eq(insn_bltu.spec_mem_wdata)

        spec_insn_bgeu_valid = Signal(1)
        spec_insn_bgeu_trap = Signal(1)
        spec_insn_bgeu_rs1_addr = Signal(5)
        spec_insn_bgeu_rs2_addr = Signal(5)
        spec_insn_bgeu_rd_addr = Signal(5)
        spec_insn_bgeu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bgeu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bgeu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_bgeu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bgeu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_bgeu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_bgeu = insn_bgeu = rvfi_insn_bgeu()
        m.d.comb += insn_bgeu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_bgeu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_bgeu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_bgeu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_bgeu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_bgeu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_bgeu_valid.eq(insn_bgeu.spec_valid)
        m.d.comb += spec_insn_bgeu_trap.eq(insn_bgeu.spec_trap)
        m.d.comb += spec_insn_bgeu_rs1_addr.eq(insn_bgeu.spec_rs1_addr)
        m.d.comb += spec_insn_bgeu_rs2_addr.eq(insn_bgeu.spec_rs2_addr)
        m.d.comb += spec_insn_bgeu_rd_addr.eq(insn_bgeu.spec_rd_addr)
        m.d.comb += spec_insn_bgeu_rd_wdata.eq(insn_bgeu.spec_rd_wdata)
        m.d.comb += spec_insn_bgeu_pc_wdata.eq(insn_bgeu.spec_pc_wdata)
        m.d.comb += spec_insn_bgeu_mem_addr.eq(insn_bgeu.spec_mem_addr)
        m.d.comb += spec_insn_bgeu_mem_rmask.eq(insn_bgeu.spec_mem_rmask)
        m.d.comb += spec_insn_bgeu_mem_wmask.eq(insn_bgeu.spec_mem_wmask)
        m.d.comb += spec_insn_bgeu_mem_wdata.eq(insn_bgeu.spec_mem_wdata)

        spec_insn_lb_valid = Signal(1)
        spec_insn_lb_trap = Signal(1)
        spec_insn_lb_rs1_addr = Signal(5)
        spec_insn_lb_rs2_addr = Signal(5)
        spec_insn_lb_rd_addr = Signal(5)
        spec_insn_lb_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lb_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lb_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lb_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lb_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lb_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lb = insn_lb = rvfi_insn_lb()
        m.d.comb += insn_lb.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lb.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lb.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lb.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lb.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lb.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lb_valid.eq(insn_lb.spec_valid)
        m.d.comb += spec_insn_lb_trap.eq(insn_lb.spec_trap)
        m.d.comb += spec_insn_lb_rs1_addr.eq(insn_lb.spec_rs1_addr)
        m.d.comb += spec_insn_lb_rs2_addr.eq(insn_lb.spec_rs2_addr)
        m.d.comb += spec_insn_lb_rd_addr.eq(insn_lb.spec_rd_addr)
        m.d.comb += spec_insn_lb_rd_wdata.eq(insn_lb.spec_rd_wdata)
        m.d.comb += spec_insn_lb_pc_wdata.eq(insn_lb.spec_pc_wdata)
        m.d.comb += spec_insn_lb_mem_addr.eq(insn_lb.spec_mem_addr)
        m.d.comb += spec_insn_lb_mem_rmask.eq(insn_lb.spec_mem_rmask)
        m.d.comb += spec_insn_lb_mem_wmask.eq(insn_lb.spec_mem_wmask)
        m.d.comb += spec_insn_lb_mem_wdata.eq(insn_lb.spec_mem_wdata)

        spec_insn_lh_valid = Signal(1)
        spec_insn_lh_trap = Signal(1)
        spec_insn_lh_rs1_addr = Signal(5)
        spec_insn_lh_rs2_addr = Signal(5)
        spec_insn_lh_rd_addr = Signal(5)
        spec_insn_lh_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lh_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lh_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lh_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lh_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lh_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lh = insn_lh = rvfi_insn_lh()
        m.d.comb += insn_lh.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lh.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lh.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lh.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lh.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lh.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lh_valid.eq(insn_lh.spec_valid)
        m.d.comb += spec_insn_lh_trap.eq(insn_lh.spec_trap)
        m.d.comb += spec_insn_lh_rs1_addr.eq(insn_lh.spec_rs1_addr)
        m.d.comb += spec_insn_lh_rs2_addr.eq(insn_lh.spec_rs2_addr)
        m.d.comb += spec_insn_lh_rd_addr.eq(insn_lh.spec_rd_addr)
        m.d.comb += spec_insn_lh_rd_wdata.eq(insn_lh.spec_rd_wdata)
        m.d.comb += spec_insn_lh_pc_wdata.eq(insn_lh.spec_pc_wdata)
        m.d.comb += spec_insn_lh_mem_addr.eq(insn_lh.spec_mem_addr)
        m.d.comb += spec_insn_lh_mem_rmask.eq(insn_lh.spec_mem_rmask)
        m.d.comb += spec_insn_lh_mem_wmask.eq(insn_lh.spec_mem_wmask)
        m.d.comb += spec_insn_lh_mem_wdata.eq(insn_lh.spec_mem_wdata)

        spec_insn_lw_valid = Signal(1)
        spec_insn_lw_trap = Signal(1)
        spec_insn_lw_rs1_addr = Signal(5)
        spec_insn_lw_rs2_addr = Signal(5)
        spec_insn_lw_rd_addr = Signal(5)
        spec_insn_lw_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lw_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lw_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lw_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lw_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lw_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lw = insn_lw = rvfi_insn_lw()
        m.d.comb += insn_lw.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lw.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lw.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lw.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lw.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lw.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lw_valid.eq(insn_lw.spec_valid)
        m.d.comb += spec_insn_lw_trap.eq(insn_lw.spec_trap)
        m.d.comb += spec_insn_lw_rs1_addr.eq(insn_lw.spec_rs1_addr)
        m.d.comb += spec_insn_lw_rs2_addr.eq(insn_lw.spec_rs2_addr)
        m.d.comb += spec_insn_lw_rd_addr.eq(insn_lw.spec_rd_addr)
        m.d.comb += spec_insn_lw_rd_wdata.eq(insn_lw.spec_rd_wdata)
        m.d.comb += spec_insn_lw_pc_wdata.eq(insn_lw.spec_pc_wdata)
        m.d.comb += spec_insn_lw_mem_addr.eq(insn_lw.spec_mem_addr)
        m.d.comb += spec_insn_lw_mem_rmask.eq(insn_lw.spec_mem_rmask)
        m.d.comb += spec_insn_lw_mem_wmask.eq(insn_lw.spec_mem_wmask)
        m.d.comb += spec_insn_lw_mem_wdata.eq(insn_lw.spec_mem_wdata)

        spec_insn_lbu_valid = Signal(1)
        spec_insn_lbu_trap = Signal(1)
        spec_insn_lbu_rs1_addr = Signal(5)
        spec_insn_lbu_rs2_addr = Signal(5)
        spec_insn_lbu_rd_addr = Signal(5)
        spec_insn_lbu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lbu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lbu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lbu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lbu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lbu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lbu = insn_lbu = rvfi_insn_lbu()
        m.d.comb += insn_lbu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lbu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lbu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lbu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lbu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lbu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lbu_valid.eq(insn_lbu.spec_valid)
        m.d.comb += spec_insn_lbu_trap.eq(insn_lbu.spec_trap)
        m.d.comb += spec_insn_lbu_rs1_addr.eq(insn_lbu.spec_rs1_addr)
        m.d.comb += spec_insn_lbu_rs2_addr.eq(insn_lbu.spec_rs2_addr)
        m.d.comb += spec_insn_lbu_rd_addr.eq(insn_lbu.spec_rd_addr)
        m.d.comb += spec_insn_lbu_rd_wdata.eq(insn_lbu.spec_rd_wdata)
        m.d.comb += spec_insn_lbu_pc_wdata.eq(insn_lbu.spec_pc_wdata)
        m.d.comb += spec_insn_lbu_mem_addr.eq(insn_lbu.spec_mem_addr)
        m.d.comb += spec_insn_lbu_mem_rmask.eq(insn_lbu.spec_mem_rmask)
        m.d.comb += spec_insn_lbu_mem_wmask.eq(insn_lbu.spec_mem_wmask)
        m.d.comb += spec_insn_lbu_mem_wdata.eq(insn_lbu.spec_mem_wdata)

        spec_insn_lhu_valid = Signal(1)
        spec_insn_lhu_trap = Signal(1)
        spec_insn_lhu_rs1_addr = Signal(5)
        spec_insn_lhu_rs2_addr = Signal(5)
        spec_insn_lhu_rd_addr = Signal(5)
        spec_insn_lhu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lhu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lhu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_lhu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lhu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_lhu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_lhu = insn_lhu = rvfi_insn_lhu()
        m.d.comb += insn_lhu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_lhu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_lhu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_lhu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_lhu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_lhu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_lhu_valid.eq(insn_lhu.spec_valid)
        m.d.comb += spec_insn_lhu_trap.eq(insn_lhu.spec_trap)
        m.d.comb += spec_insn_lhu_rs1_addr.eq(insn_lhu.spec_rs1_addr)
        m.d.comb += spec_insn_lhu_rs2_addr.eq(insn_lhu.spec_rs2_addr)
        m.d.comb += spec_insn_lhu_rd_addr.eq(insn_lhu.spec_rd_addr)
        m.d.comb += spec_insn_lhu_rd_wdata.eq(insn_lhu.spec_rd_wdata)
        m.d.comb += spec_insn_lhu_pc_wdata.eq(insn_lhu.spec_pc_wdata)
        m.d.comb += spec_insn_lhu_mem_addr.eq(insn_lhu.spec_mem_addr)
        m.d.comb += spec_insn_lhu_mem_rmask.eq(insn_lhu.spec_mem_rmask)
        m.d.comb += spec_insn_lhu_mem_wmask.eq(insn_lhu.spec_mem_wmask)
        m.d.comb += spec_insn_lhu_mem_wdata.eq(insn_lhu.spec_mem_wdata)

        spec_insn_sb_valid = Signal(1)
        spec_insn_sb_trap = Signal(1)
        spec_insn_sb_rs1_addr = Signal(5)
        spec_insn_sb_rs2_addr = Signal(5)
        spec_insn_sb_rd_addr = Signal(5)
        spec_insn_sb_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sb_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sb_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sb_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sb_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sb_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sb = insn_sb = rvfi_insn_sb()
        m.d.comb += insn_sb.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sb.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sb.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sb.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sb.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sb.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sb_valid.eq(insn_sb.spec_valid)
        m.d.comb += spec_insn_sb_trap.eq(insn_sb.spec_trap)
        m.d.comb += spec_insn_sb_rs1_addr.eq(insn_sb.spec_rs1_addr)
        m.d.comb += spec_insn_sb_rs2_addr.eq(insn_sb.spec_rs2_addr)
        m.d.comb += spec_insn_sb_rd_addr.eq(insn_sb.spec_rd_addr)
        m.d.comb += spec_insn_sb_rd_wdata.eq(insn_sb.spec_rd_wdata)
        m.d.comb += spec_insn_sb_pc_wdata.eq(insn_sb.spec_pc_wdata)
        m.d.comb += spec_insn_sb_mem_addr.eq(insn_sb.spec_mem_addr)
        m.d.comb += spec_insn_sb_mem_rmask.eq(insn_sb.spec_mem_rmask)
        m.d.comb += spec_insn_sb_mem_wmask.eq(insn_sb.spec_mem_wmask)
        m.d.comb += spec_insn_sb_mem_wdata.eq(insn_sb.spec_mem_wdata)

        spec_insn_sh_valid = Signal(1)
        spec_insn_sh_trap = Signal(1)
        spec_insn_sh_rs1_addr = Signal(5)
        spec_insn_sh_rs2_addr = Signal(5)
        spec_insn_sh_rd_addr = Signal(5)
        spec_insn_sh_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sh_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sh_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sh_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sh_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sh_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sh = insn_sh = rvfi_insn_sh()
        m.d.comb += insn_sh.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sh.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sh.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sh.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sh.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sh.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sh_valid.eq(insn_sh.spec_valid)
        m.d.comb += spec_insn_sh_trap.eq(insn_sh.spec_trap)
        m.d.comb += spec_insn_sh_rs1_addr.eq(insn_sh.spec_rs1_addr)
        m.d.comb += spec_insn_sh_rs2_addr.eq(insn_sh.spec_rs2_addr)
        m.d.comb += spec_insn_sh_rd_addr.eq(insn_sh.spec_rd_addr)
        m.d.comb += spec_insn_sh_rd_wdata.eq(insn_sh.spec_rd_wdata)
        m.d.comb += spec_insn_sh_pc_wdata.eq(insn_sh.spec_pc_wdata)
        m.d.comb += spec_insn_sh_mem_addr.eq(insn_sh.spec_mem_addr)
        m.d.comb += spec_insn_sh_mem_rmask.eq(insn_sh.spec_mem_rmask)
        m.d.comb += spec_insn_sh_mem_wmask.eq(insn_sh.spec_mem_wmask)
        m.d.comb += spec_insn_sh_mem_wdata.eq(insn_sh.spec_mem_wdata)

        spec_insn_sw_valid = Signal(1)
        spec_insn_sw_trap = Signal(1)
        spec_insn_sw_rs1_addr = Signal(5)
        spec_insn_sw_rs2_addr = Signal(5)
        spec_insn_sw_rd_addr = Signal(5)
        spec_insn_sw_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sw_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sw_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sw_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sw_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sw_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sw = insn_sw = rvfi_insn_sw()
        m.d.comb += insn_sw.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sw.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sw.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sw.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sw.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sw.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sw_valid.eq(insn_sw.spec_valid)
        m.d.comb += spec_insn_sw_trap.eq(insn_sw.spec_trap)
        m.d.comb += spec_insn_sw_rs1_addr.eq(insn_sw.spec_rs1_addr)
        m.d.comb += spec_insn_sw_rs2_addr.eq(insn_sw.spec_rs2_addr)
        m.d.comb += spec_insn_sw_rd_addr.eq(insn_sw.spec_rd_addr)
        m.d.comb += spec_insn_sw_rd_wdata.eq(insn_sw.spec_rd_wdata)
        m.d.comb += spec_insn_sw_pc_wdata.eq(insn_sw.spec_pc_wdata)
        m.d.comb += spec_insn_sw_mem_addr.eq(insn_sw.spec_mem_addr)
        m.d.comb += spec_insn_sw_mem_rmask.eq(insn_sw.spec_mem_rmask)
        m.d.comb += spec_insn_sw_mem_wmask.eq(insn_sw.spec_mem_wmask)
        m.d.comb += spec_insn_sw_mem_wdata.eq(insn_sw.spec_mem_wdata)

        spec_insn_addi_valid = Signal(1)
        spec_insn_addi_trap = Signal(1)
        spec_insn_addi_rs1_addr = Signal(5)
        spec_insn_addi_rs2_addr = Signal(5)
        spec_insn_addi_rd_addr = Signal(5)
        spec_insn_addi_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_addi_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_addi_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_addi_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_addi_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_addi_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_addi = insn_addi = rvfi_insn_addi()
        m.d.comb += insn_addi.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_addi.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_addi.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_addi.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_addi.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_addi.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_addi_valid.eq(insn_addi.spec_valid)
        m.d.comb += spec_insn_addi_trap.eq(insn_addi.spec_trap)
        m.d.comb += spec_insn_addi_rs1_addr.eq(insn_addi.spec_rs1_addr)
        m.d.comb += spec_insn_addi_rs2_addr.eq(insn_addi.spec_rs2_addr)
        m.d.comb += spec_insn_addi_rd_addr.eq(insn_addi.spec_rd_addr)
        m.d.comb += spec_insn_addi_rd_wdata.eq(insn_addi.spec_rd_wdata)
        m.d.comb += spec_insn_addi_pc_wdata.eq(insn_addi.spec_pc_wdata)
        m.d.comb += spec_insn_addi_mem_addr.eq(insn_addi.spec_mem_addr)
        m.d.comb += spec_insn_addi_mem_rmask.eq(insn_addi.spec_mem_rmask)
        m.d.comb += spec_insn_addi_mem_wmask.eq(insn_addi.spec_mem_wmask)
        m.d.comb += spec_insn_addi_mem_wdata.eq(insn_addi.spec_mem_wdata)

        spec_insn_slti_valid = Signal(1)
        spec_insn_slti_trap = Signal(1)
        spec_insn_slti_rs1_addr = Signal(5)
        spec_insn_slti_rs2_addr = Signal(5)
        spec_insn_slti_rd_addr = Signal(5)
        spec_insn_slti_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slti_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slti_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slti_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slti_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slti_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_slti = insn_slti = rvfi_insn_slti()
        m.d.comb += insn_slti.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_slti.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_slti.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_slti.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_slti.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_slti.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_slti_valid.eq(insn_slti.spec_valid)
        m.d.comb += spec_insn_slti_trap.eq(insn_slti.spec_trap)
        m.d.comb += spec_insn_slti_rs1_addr.eq(insn_slti.spec_rs1_addr)
        m.d.comb += spec_insn_slti_rs2_addr.eq(insn_slti.spec_rs2_addr)
        m.d.comb += spec_insn_slti_rd_addr.eq(insn_slti.spec_rd_addr)
        m.d.comb += spec_insn_slti_rd_wdata.eq(insn_slti.spec_rd_wdata)
        m.d.comb += spec_insn_slti_pc_wdata.eq(insn_slti.spec_pc_wdata)
        m.d.comb += spec_insn_slti_mem_addr.eq(insn_slti.spec_mem_addr)
        m.d.comb += spec_insn_slti_mem_rmask.eq(insn_slti.spec_mem_rmask)
        m.d.comb += spec_insn_slti_mem_wmask.eq(insn_slti.spec_mem_wmask)
        m.d.comb += spec_insn_slti_mem_wdata.eq(insn_slti.spec_mem_wdata)

        spec_insn_sltiu_valid = Signal(1)
        spec_insn_sltiu_trap = Signal(1)
        spec_insn_sltiu_rs1_addr = Signal(5)
        spec_insn_sltiu_rs2_addr = Signal(5)
        spec_insn_sltiu_rd_addr = Signal(5)
        spec_insn_sltiu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltiu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltiu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltiu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sltiu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sltiu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sltiu = insn_sltiu = rvfi_insn_sltiu()
        m.d.comb += insn_sltiu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sltiu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sltiu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sltiu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sltiu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sltiu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sltiu_valid.eq(insn_sltiu.spec_valid)
        m.d.comb += spec_insn_sltiu_trap.eq(insn_sltiu.spec_trap)
        m.d.comb += spec_insn_sltiu_rs1_addr.eq(insn_sltiu.spec_rs1_addr)
        m.d.comb += spec_insn_sltiu_rs2_addr.eq(insn_sltiu.spec_rs2_addr)
        m.d.comb += spec_insn_sltiu_rd_addr.eq(insn_sltiu.spec_rd_addr)
        m.d.comb += spec_insn_sltiu_rd_wdata.eq(insn_sltiu.spec_rd_wdata)
        m.d.comb += spec_insn_sltiu_pc_wdata.eq(insn_sltiu.spec_pc_wdata)
        m.d.comb += spec_insn_sltiu_mem_addr.eq(insn_sltiu.spec_mem_addr)
        m.d.comb += spec_insn_sltiu_mem_rmask.eq(insn_sltiu.spec_mem_rmask)
        m.d.comb += spec_insn_sltiu_mem_wmask.eq(insn_sltiu.spec_mem_wmask)
        m.d.comb += spec_insn_sltiu_mem_wdata.eq(insn_sltiu.spec_mem_wdata)

        spec_insn_xori_valid = Signal(1)
        spec_insn_xori_trap = Signal(1)
        spec_insn_xori_rs1_addr = Signal(5)
        spec_insn_xori_rs2_addr = Signal(5)
        spec_insn_xori_rd_addr = Signal(5)
        spec_insn_xori_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xori_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xori_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xori_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_xori_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_xori_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_xori = insn_xori = rvfi_insn_xori()
        m.d.comb += insn_xori.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_xori.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_xori.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_xori.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_xori.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_xori.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_xori_valid.eq(insn_xori.spec_valid)
        m.d.comb += spec_insn_xori_trap.eq(insn_xori.spec_trap)
        m.d.comb += spec_insn_xori_rs1_addr.eq(insn_xori.spec_rs1_addr)
        m.d.comb += spec_insn_xori_rs2_addr.eq(insn_xori.spec_rs2_addr)
        m.d.comb += spec_insn_xori_rd_addr.eq(insn_xori.spec_rd_addr)
        m.d.comb += spec_insn_xori_rd_wdata.eq(insn_xori.spec_rd_wdata)
        m.d.comb += spec_insn_xori_pc_wdata.eq(insn_xori.spec_pc_wdata)
        m.d.comb += spec_insn_xori_mem_addr.eq(insn_xori.spec_mem_addr)
        m.d.comb += spec_insn_xori_mem_rmask.eq(insn_xori.spec_mem_rmask)
        m.d.comb += spec_insn_xori_mem_wmask.eq(insn_xori.spec_mem_wmask)
        m.d.comb += spec_insn_xori_mem_wdata.eq(insn_xori.spec_mem_wdata)

        spec_insn_ori_valid = Signal(1)
        spec_insn_ori_trap = Signal(1)
        spec_insn_ori_rs1_addr = Signal(5)
        spec_insn_ori_rs2_addr = Signal(5)
        spec_insn_ori_rd_addr = Signal(5)
        spec_insn_ori_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_ori_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_ori_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_ori_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_ori_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_ori_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_ori = insn_ori = rvfi_insn_ori()
        m.d.comb += insn_ori.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_ori.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_ori.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_ori.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_ori.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_ori.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_ori_valid.eq(insn_ori.spec_valid)
        m.d.comb += spec_insn_ori_trap.eq(insn_ori.spec_trap)
        m.d.comb += spec_insn_ori_rs1_addr.eq(insn_ori.spec_rs1_addr)
        m.d.comb += spec_insn_ori_rs2_addr.eq(insn_ori.spec_rs2_addr)
        m.d.comb += spec_insn_ori_rd_addr.eq(insn_ori.spec_rd_addr)
        m.d.comb += spec_insn_ori_rd_wdata.eq(insn_ori.spec_rd_wdata)
        m.d.comb += spec_insn_ori_pc_wdata.eq(insn_ori.spec_pc_wdata)
        m.d.comb += spec_insn_ori_mem_addr.eq(insn_ori.spec_mem_addr)
        m.d.comb += spec_insn_ori_mem_rmask.eq(insn_ori.spec_mem_rmask)
        m.d.comb += spec_insn_ori_mem_wmask.eq(insn_ori.spec_mem_wmask)
        m.d.comb += spec_insn_ori_mem_wdata.eq(insn_ori.spec_mem_wdata)

        spec_insn_andi_valid = Signal(1)
        spec_insn_andi_trap = Signal(1)
        spec_insn_andi_rs1_addr = Signal(5)
        spec_insn_andi_rs2_addr = Signal(5)
        spec_insn_andi_rd_addr = Signal(5)
        spec_insn_andi_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_andi_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_andi_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_andi_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_andi_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_andi_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_andi = insn_andi = rvfi_insn_andi()
        m.d.comb += insn_andi.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_andi.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_andi.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_andi.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_andi.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_andi.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_andi_valid.eq(insn_andi.spec_valid)
        m.d.comb += spec_insn_andi_trap.eq(insn_andi.spec_trap)
        m.d.comb += spec_insn_andi_rs1_addr.eq(insn_andi.spec_rs1_addr)
        m.d.comb += spec_insn_andi_rs2_addr.eq(insn_andi.spec_rs2_addr)
        m.d.comb += spec_insn_andi_rd_addr.eq(insn_andi.spec_rd_addr)
        m.d.comb += spec_insn_andi_rd_wdata.eq(insn_andi.spec_rd_wdata)
        m.d.comb += spec_insn_andi_pc_wdata.eq(insn_andi.spec_pc_wdata)
        m.d.comb += spec_insn_andi_mem_addr.eq(insn_andi.spec_mem_addr)
        m.d.comb += spec_insn_andi_mem_rmask.eq(insn_andi.spec_mem_rmask)
        m.d.comb += spec_insn_andi_mem_wmask.eq(insn_andi.spec_mem_wmask)
        m.d.comb += spec_insn_andi_mem_wdata.eq(insn_andi.spec_mem_wdata)

        spec_insn_slli_valid = Signal(1)
        spec_insn_slli_trap = Signal(1)
        spec_insn_slli_rs1_addr = Signal(5)
        spec_insn_slli_rs2_addr = Signal(5)
        spec_insn_slli_rd_addr = Signal(5)
        spec_insn_slli_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slli_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slli_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slli_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slli_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slli_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_slli = insn_slli = rvfi_insn_slli()
        m.d.comb += insn_slli.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_slli.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_slli.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_slli.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_slli.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_slli.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_slli_valid.eq(insn_slli.spec_valid)
        m.d.comb += spec_insn_slli_trap.eq(insn_slli.spec_trap)
        m.d.comb += spec_insn_slli_rs1_addr.eq(insn_slli.spec_rs1_addr)
        m.d.comb += spec_insn_slli_rs2_addr.eq(insn_slli.spec_rs2_addr)
        m.d.comb += spec_insn_slli_rd_addr.eq(insn_slli.spec_rd_addr)
        m.d.comb += spec_insn_slli_rd_wdata.eq(insn_slli.spec_rd_wdata)
        m.d.comb += spec_insn_slli_pc_wdata.eq(insn_slli.spec_pc_wdata)
        m.d.comb += spec_insn_slli_mem_addr.eq(insn_slli.spec_mem_addr)
        m.d.comb += spec_insn_slli_mem_rmask.eq(insn_slli.spec_mem_rmask)
        m.d.comb += spec_insn_slli_mem_wmask.eq(insn_slli.spec_mem_wmask)
        m.d.comb += spec_insn_slli_mem_wdata.eq(insn_slli.spec_mem_wdata)

        spec_insn_srli_valid = Signal(1)
        spec_insn_srli_trap = Signal(1)
        spec_insn_srli_rs1_addr = Signal(5)
        spec_insn_srli_rs2_addr = Signal(5)
        spec_insn_srli_rd_addr = Signal(5)
        spec_insn_srli_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srli_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srli_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srli_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srli_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srli_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_srli = insn_srli = rvfi_insn_srli()
        m.d.comb += insn_srli.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_srli.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_srli.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_srli.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_srli.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_srli.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_srli_valid.eq(insn_srli.spec_valid)
        m.d.comb += spec_insn_srli_trap.eq(insn_srli.spec_trap)
        m.d.comb += spec_insn_srli_rs1_addr.eq(insn_srli.spec_rs1_addr)
        m.d.comb += spec_insn_srli_rs2_addr.eq(insn_srli.spec_rs2_addr)
        m.d.comb += spec_insn_srli_rd_addr.eq(insn_srli.spec_rd_addr)
        m.d.comb += spec_insn_srli_rd_wdata.eq(insn_srli.spec_rd_wdata)
        m.d.comb += spec_insn_srli_pc_wdata.eq(insn_srli.spec_pc_wdata)
        m.d.comb += spec_insn_srli_mem_addr.eq(insn_srli.spec_mem_addr)
        m.d.comb += spec_insn_srli_mem_rmask.eq(insn_srli.spec_mem_rmask)
        m.d.comb += spec_insn_srli_mem_wmask.eq(insn_srli.spec_mem_wmask)
        m.d.comb += spec_insn_srli_mem_wdata.eq(insn_srli.spec_mem_wdata)

        spec_insn_srai_valid = Signal(1)
        spec_insn_srai_trap = Signal(1)
        spec_insn_srai_rs1_addr = Signal(5)
        spec_insn_srai_rs2_addr = Signal(5)
        spec_insn_srai_rd_addr = Signal(5)
        spec_insn_srai_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srai_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srai_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srai_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srai_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srai_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_srai = insn_srai = rvfi_insn_srai()
        m.d.comb += insn_srai.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_srai.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_srai.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_srai.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_srai.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_srai.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_srai_valid.eq(insn_srai.spec_valid)
        m.d.comb += spec_insn_srai_trap.eq(insn_srai.spec_trap)
        m.d.comb += spec_insn_srai_rs1_addr.eq(insn_srai.spec_rs1_addr)
        m.d.comb += spec_insn_srai_rs2_addr.eq(insn_srai.spec_rs2_addr)
        m.d.comb += spec_insn_srai_rd_addr.eq(insn_srai.spec_rd_addr)
        m.d.comb += spec_insn_srai_rd_wdata.eq(insn_srai.spec_rd_wdata)
        m.d.comb += spec_insn_srai_pc_wdata.eq(insn_srai.spec_pc_wdata)
        m.d.comb += spec_insn_srai_mem_addr.eq(insn_srai.spec_mem_addr)
        m.d.comb += spec_insn_srai_mem_rmask.eq(insn_srai.spec_mem_rmask)
        m.d.comb += spec_insn_srai_mem_wmask.eq(insn_srai.spec_mem_wmask)
        m.d.comb += spec_insn_srai_mem_wdata.eq(insn_srai.spec_mem_wdata)

        spec_insn_add_valid = Signal(1)
        spec_insn_add_trap = Signal(1)
        spec_insn_add_rs1_addr = Signal(5)
        spec_insn_add_rs2_addr = Signal(5)
        spec_insn_add_rd_addr = Signal(5)
        spec_insn_add_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_add_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_add_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_add_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_add_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_add_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_add = insn_add = rvfi_insn_add()
        m.d.comb += insn_add.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_add.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_add.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_add.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_add.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_add.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_add_valid.eq(insn_add.spec_valid)
        m.d.comb += spec_insn_add_trap.eq(insn_add.spec_trap)
        m.d.comb += spec_insn_add_rs1_addr.eq(insn_add.spec_rs1_addr)
        m.d.comb += spec_insn_add_rs2_addr.eq(insn_add.spec_rs2_addr)
        m.d.comb += spec_insn_add_rd_addr.eq(insn_add.spec_rd_addr)
        m.d.comb += spec_insn_add_rd_wdata.eq(insn_add.spec_rd_wdata)
        m.d.comb += spec_insn_add_pc_wdata.eq(insn_add.spec_pc_wdata)
        m.d.comb += spec_insn_add_mem_addr.eq(insn_add.spec_mem_addr)
        m.d.comb += spec_insn_add_mem_rmask.eq(insn_add.spec_mem_rmask)
        m.d.comb += spec_insn_add_mem_wmask.eq(insn_add.spec_mem_wmask)
        m.d.comb += spec_insn_add_mem_wdata.eq(insn_add.spec_mem_wdata)

        spec_insn_sub_valid = Signal(1)
        spec_insn_sub_trap = Signal(1)
        spec_insn_sub_rs1_addr = Signal(5)
        spec_insn_sub_rs2_addr = Signal(5)
        spec_insn_sub_rd_addr = Signal(5)
        spec_insn_sub_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sub_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sub_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sub_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sub_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sub_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sub = insn_sub = rvfi_insn_sub()
        m.d.comb += insn_sub.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sub.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sub.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sub.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sub.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sub.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sub_valid.eq(insn_sub.spec_valid)
        m.d.comb += spec_insn_sub_trap.eq(insn_sub.spec_trap)
        m.d.comb += spec_insn_sub_rs1_addr.eq(insn_sub.spec_rs1_addr)
        m.d.comb += spec_insn_sub_rs2_addr.eq(insn_sub.spec_rs2_addr)
        m.d.comb += spec_insn_sub_rd_addr.eq(insn_sub.spec_rd_addr)
        m.d.comb += spec_insn_sub_rd_wdata.eq(insn_sub.spec_rd_wdata)
        m.d.comb += spec_insn_sub_pc_wdata.eq(insn_sub.spec_pc_wdata)
        m.d.comb += spec_insn_sub_mem_addr.eq(insn_sub.spec_mem_addr)
        m.d.comb += spec_insn_sub_mem_rmask.eq(insn_sub.spec_mem_rmask)
        m.d.comb += spec_insn_sub_mem_wmask.eq(insn_sub.spec_mem_wmask)
        m.d.comb += spec_insn_sub_mem_wdata.eq(insn_sub.spec_mem_wdata)

        spec_insn_sll_valid = Signal(1)
        spec_insn_sll_trap = Signal(1)
        spec_insn_sll_rs1_addr = Signal(5)
        spec_insn_sll_rs2_addr = Signal(5)
        spec_insn_sll_rd_addr = Signal(5)
        spec_insn_sll_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sll_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sll_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sll_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sll_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sll_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sll = insn_sll = rvfi_insn_sll()
        m.d.comb += insn_sll.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sll.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sll.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sll.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sll.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sll.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sll_valid.eq(insn_sll.spec_valid)
        m.d.comb += spec_insn_sll_trap.eq(insn_sll.spec_trap)
        m.d.comb += spec_insn_sll_rs1_addr.eq(insn_sll.spec_rs1_addr)
        m.d.comb += spec_insn_sll_rs2_addr.eq(insn_sll.spec_rs2_addr)
        m.d.comb += spec_insn_sll_rd_addr.eq(insn_sll.spec_rd_addr)
        m.d.comb += spec_insn_sll_rd_wdata.eq(insn_sll.spec_rd_wdata)
        m.d.comb += spec_insn_sll_pc_wdata.eq(insn_sll.spec_pc_wdata)
        m.d.comb += spec_insn_sll_mem_addr.eq(insn_sll.spec_mem_addr)
        m.d.comb += spec_insn_sll_mem_rmask.eq(insn_sll.spec_mem_rmask)
        m.d.comb += spec_insn_sll_mem_wmask.eq(insn_sll.spec_mem_wmask)
        m.d.comb += spec_insn_sll_mem_wdata.eq(insn_sll.spec_mem_wdata)

        spec_insn_slt_valid = Signal(1)
        spec_insn_slt_trap = Signal(1)
        spec_insn_slt_rs1_addr = Signal(5)
        spec_insn_slt_rs2_addr = Signal(5)
        spec_insn_slt_rd_addr = Signal(5)
        spec_insn_slt_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slt_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slt_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_slt_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slt_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_slt_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_slt = insn_slt = rvfi_insn_slt()
        m.d.comb += insn_slt.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_slt.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_slt.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_slt.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_slt.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_slt.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_slt_valid.eq(insn_slt.spec_valid)
        m.d.comb += spec_insn_slt_trap.eq(insn_slt.spec_trap)
        m.d.comb += spec_insn_slt_rs1_addr.eq(insn_slt.spec_rs1_addr)
        m.d.comb += spec_insn_slt_rs2_addr.eq(insn_slt.spec_rs2_addr)
        m.d.comb += spec_insn_slt_rd_addr.eq(insn_slt.spec_rd_addr)
        m.d.comb += spec_insn_slt_rd_wdata.eq(insn_slt.spec_rd_wdata)
        m.d.comb += spec_insn_slt_pc_wdata.eq(insn_slt.spec_pc_wdata)
        m.d.comb += spec_insn_slt_mem_addr.eq(insn_slt.spec_mem_addr)
        m.d.comb += spec_insn_slt_mem_rmask.eq(insn_slt.spec_mem_rmask)
        m.d.comb += spec_insn_slt_mem_wmask.eq(insn_slt.spec_mem_wmask)
        m.d.comb += spec_insn_slt_mem_wdata.eq(insn_slt.spec_mem_wdata)

        spec_insn_sltu_valid = Signal(1)
        spec_insn_sltu_trap = Signal(1)
        spec_insn_sltu_rs1_addr = Signal(5)
        spec_insn_sltu_rs2_addr = Signal(5)
        spec_insn_sltu_rd_addr = Signal(5)
        spec_insn_sltu_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltu_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltu_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sltu_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sltu_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sltu_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sltu = insn_sltu = rvfi_insn_sltu()
        m.d.comb += insn_sltu.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sltu.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sltu.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sltu.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sltu.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sltu.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sltu_valid.eq(insn_sltu.spec_valid)
        m.d.comb += spec_insn_sltu_trap.eq(insn_sltu.spec_trap)
        m.d.comb += spec_insn_sltu_rs1_addr.eq(insn_sltu.spec_rs1_addr)
        m.d.comb += spec_insn_sltu_rs2_addr.eq(insn_sltu.spec_rs2_addr)
        m.d.comb += spec_insn_sltu_rd_addr.eq(insn_sltu.spec_rd_addr)
        m.d.comb += spec_insn_sltu_rd_wdata.eq(insn_sltu.spec_rd_wdata)
        m.d.comb += spec_insn_sltu_pc_wdata.eq(insn_sltu.spec_pc_wdata)
        m.d.comb += spec_insn_sltu_mem_addr.eq(insn_sltu.spec_mem_addr)
        m.d.comb += spec_insn_sltu_mem_rmask.eq(insn_sltu.spec_mem_rmask)
        m.d.comb += spec_insn_sltu_mem_wmask.eq(insn_sltu.spec_mem_wmask)
        m.d.comb += spec_insn_sltu_mem_wdata.eq(insn_sltu.spec_mem_wdata)

        spec_insn_xor_valid = Signal(1)
        spec_insn_xor_trap = Signal(1)
        spec_insn_xor_rs1_addr = Signal(5)
        spec_insn_xor_rs2_addr = Signal(5)
        spec_insn_xor_rd_addr = Signal(5)
        spec_insn_xor_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xor_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xor_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_xor_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_xor_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_xor_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_xor = insn_xor = rvfi_insn_xor()
        m.d.comb += insn_xor.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_xor.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_xor.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_xor.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_xor.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_xor.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_xor_valid.eq(insn_xor.spec_valid)
        m.d.comb += spec_insn_xor_trap.eq(insn_xor.spec_trap)
        m.d.comb += spec_insn_xor_rs1_addr.eq(insn_xor.spec_rs1_addr)
        m.d.comb += spec_insn_xor_rs2_addr.eq(insn_xor.spec_rs2_addr)
        m.d.comb += spec_insn_xor_rd_addr.eq(insn_xor.spec_rd_addr)
        m.d.comb += spec_insn_xor_rd_wdata.eq(insn_xor.spec_rd_wdata)
        m.d.comb += spec_insn_xor_pc_wdata.eq(insn_xor.spec_pc_wdata)
        m.d.comb += spec_insn_xor_mem_addr.eq(insn_xor.spec_mem_addr)
        m.d.comb += spec_insn_xor_mem_rmask.eq(insn_xor.spec_mem_rmask)
        m.d.comb += spec_insn_xor_mem_wmask.eq(insn_xor.spec_mem_wmask)
        m.d.comb += spec_insn_xor_mem_wdata.eq(insn_xor.spec_mem_wdata)

        spec_insn_srl_valid = Signal(1)
        spec_insn_srl_trap = Signal(1)
        spec_insn_srl_rs1_addr = Signal(5)
        spec_insn_srl_rs2_addr = Signal(5)
        spec_insn_srl_rd_addr = Signal(5)
        spec_insn_srl_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srl_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srl_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_srl_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srl_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_srl_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_srl = insn_srl = rvfi_insn_srl()
        m.d.comb += insn_srl.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_srl.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_srl.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_srl.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_srl.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_srl.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_srl_valid.eq(insn_srl.spec_valid)
        m.d.comb += spec_insn_srl_trap.eq(insn_srl.spec_trap)
        m.d.comb += spec_insn_srl_rs1_addr.eq(insn_srl.spec_rs1_addr)
        m.d.comb += spec_insn_srl_rs2_addr.eq(insn_srl.spec_rs2_addr)
        m.d.comb += spec_insn_srl_rd_addr.eq(insn_srl.spec_rd_addr)
        m.d.comb += spec_insn_srl_rd_wdata.eq(insn_srl.spec_rd_wdata)
        m.d.comb += spec_insn_srl_pc_wdata.eq(insn_srl.spec_pc_wdata)
        m.d.comb += spec_insn_srl_mem_addr.eq(insn_srl.spec_mem_addr)
        m.d.comb += spec_insn_srl_mem_rmask.eq(insn_srl.spec_mem_rmask)
        m.d.comb += spec_insn_srl_mem_wmask.eq(insn_srl.spec_mem_wmask)
        m.d.comb += spec_insn_srl_mem_wdata.eq(insn_srl.spec_mem_wdata)

        spec_insn_sra_valid = Signal(1)
        spec_insn_sra_trap = Signal(1)
        spec_insn_sra_rs1_addr = Signal(5)
        spec_insn_sra_rs2_addr = Signal(5)
        spec_insn_sra_rd_addr = Signal(5)
        spec_insn_sra_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sra_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sra_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_sra_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sra_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_sra_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_sra = insn_sra = rvfi_insn_sra()
        m.d.comb += insn_sra.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_sra.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_sra.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_sra.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_sra.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_sra.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_sra_valid.eq(insn_sra.spec_valid)
        m.d.comb += spec_insn_sra_trap.eq(insn_sra.spec_trap)
        m.d.comb += spec_insn_sra_rs1_addr.eq(insn_sra.spec_rs1_addr)
        m.d.comb += spec_insn_sra_rs2_addr.eq(insn_sra.spec_rs2_addr)
        m.d.comb += spec_insn_sra_rd_addr.eq(insn_sra.spec_rd_addr)
        m.d.comb += spec_insn_sra_rd_wdata.eq(insn_sra.spec_rd_wdata)
        m.d.comb += spec_insn_sra_pc_wdata.eq(insn_sra.spec_pc_wdata)
        m.d.comb += spec_insn_sra_mem_addr.eq(insn_sra.spec_mem_addr)
        m.d.comb += spec_insn_sra_mem_rmask.eq(insn_sra.spec_mem_rmask)
        m.d.comb += spec_insn_sra_mem_wmask.eq(insn_sra.spec_mem_wmask)
        m.d.comb += spec_insn_sra_mem_wdata.eq(insn_sra.spec_mem_wdata)

        spec_insn_or_valid = Signal(1)
        spec_insn_or_trap = Signal(1)
        spec_insn_or_rs1_addr = Signal(5)
        spec_insn_or_rs2_addr = Signal(5)
        spec_insn_or_rd_addr = Signal(5)
        spec_insn_or_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_or_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_or_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_or_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_or_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_or_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_or = insn_or = rvfi_insn_or()
        m.d.comb += insn_or.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_or.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_or.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_or.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_or.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_or.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_or_valid.eq(insn_or.spec_valid)
        m.d.comb += spec_insn_or_trap.eq(insn_or.spec_trap)
        m.d.comb += spec_insn_or_rs1_addr.eq(insn_or.spec_rs1_addr)
        m.d.comb += spec_insn_or_rs2_addr.eq(insn_or.spec_rs2_addr)
        m.d.comb += spec_insn_or_rd_addr.eq(insn_or.spec_rd_addr)
        m.d.comb += spec_insn_or_rd_wdata.eq(insn_or.spec_rd_wdata)
        m.d.comb += spec_insn_or_pc_wdata.eq(insn_or.spec_pc_wdata)
        m.d.comb += spec_insn_or_mem_addr.eq(insn_or.spec_mem_addr)
        m.d.comb += spec_insn_or_mem_rmask.eq(insn_or.spec_mem_rmask)
        m.d.comb += spec_insn_or_mem_wmask.eq(insn_or.spec_mem_wmask)
        m.d.comb += spec_insn_or_mem_wdata.eq(insn_or.spec_mem_wdata)

        spec_insn_and_valid = Signal(1)
        spec_insn_and_trap = Signal(1)
        spec_insn_and_rs1_addr = Signal(5)
        spec_insn_and_rs2_addr = Signal(5)
        spec_insn_and_rd_addr = Signal(5)
        spec_insn_and_rd_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_and_pc_wdata = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_and_mem_addr = Signal(self.RISCV_FORMAL_XLEN)
        spec_insn_and_mem_rmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_and_mem_wmask = Signal(int(self.RISCV_FORMAL_XLEN // 8))
        spec_insn_and_mem_wdata = Signal(self.RISCV_FORMAL_XLEN)
        m.submodules.insn_and = insn_and = rvfi_insn_and()
        m.d.comb += insn_and.rvfi_valid.eq(self.rvfi_valid)
        m.d.comb += insn_and.rvfi_insn.eq(self.rvfi_insn)
        m.d.comb += insn_and.rvfi_pc_rdata.eq(self.rvfi_pc_rdata)
        m.d.comb += insn_and.rvfi_rs1_rdata.eq(self.rvfi_rs1_rdata)
        m.d.comb += insn_and.rvfi_rs2_rdata.eq(self.rvfi_rs2_rdata)
        m.d.comb += insn_and.rvfi_mem_rdata.eq(self.rvfi_mem_rdata)
        m.d.comb += spec_insn_and_valid.eq(insn_and.spec_valid)
        m.d.comb += spec_insn_and_trap.eq(insn_and.spec_trap)
        m.d.comb += spec_insn_and_rs1_addr.eq(insn_and.spec_rs1_addr)
        m.d.comb += spec_insn_and_rs2_addr.eq(insn_and.spec_rs2_addr)
        m.d.comb += spec_insn_and_rd_addr.eq(insn_and.spec_rd_addr)
        m.d.comb += spec_insn_and_rd_wdata.eq(insn_and.spec_rd_wdata)
        m.d.comb += spec_insn_and_pc_wdata.eq(insn_and.spec_pc_wdata)
        m.d.comb += spec_insn_and_mem_addr.eq(insn_and.spec_mem_addr)
        m.d.comb += spec_insn_and_mem_rmask.eq(insn_and.spec_mem_rmask)
        m.d.comb += spec_insn_and_mem_wmask.eq(insn_and.spec_mem_wmask)
        m.d.comb += spec_insn_and_mem_wdata.eq(insn_and.spec_mem_wdata)

        m.d.comb += self.spec_valid.eq(Mux(spec_insn_and_valid, spec_insn_and_valid, Mux(spec_insn_or_valid, spec_insn_or_valid, Mux(spec_insn_sra_valid, spec_insn_sra_valid, Mux(spec_insn_srl_valid, spec_insn_srl_valid, Mux(spec_insn_xor_valid, spec_insn_xor_valid, Mux(spec_insn_sltu_valid, spec_insn_sltu_valid, Mux(spec_insn_slt_valid, spec_insn_slt_valid, Mux(spec_insn_sll_valid, spec_insn_sll_valid, Mux(spec_insn_sub_valid, spec_insn_sub_valid, Mux(spec_insn_add_valid, spec_insn_add_valid, Mux(spec_insn_srai_valid, spec_insn_srai_valid, Mux(spec_insn_srli_valid, spec_insn_srli_valid, Mux(spec_insn_slli_valid, spec_insn_slli_valid, Mux(spec_insn_andi_valid, spec_insn_andi_valid, Mux(spec_insn_ori_valid, spec_insn_ori_valid, Mux(spec_insn_xori_valid, spec_insn_xori_valid, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_valid, Mux(spec_insn_slti_valid, spec_insn_slti_valid, Mux(spec_insn_addi_valid, spec_insn_addi_valid, Mux(spec_insn_sw_valid, spec_insn_sw_valid, Mux(spec_insn_sh_valid, spec_insn_sh_valid, Mux(spec_insn_sb_valid, spec_insn_sb_valid, Mux(spec_insn_lhu_valid, spec_insn_lhu_valid, Mux(spec_insn_lbu_valid, spec_insn_lbu_valid, Mux(spec_insn_lw_valid, spec_insn_lw_valid, Mux(spec_insn_lh_valid, spec_insn_lh_valid, Mux(spec_insn_lb_valid, spec_insn_lb_valid, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_valid, Mux(spec_insn_bltu_valid, spec_insn_bltu_valid, Mux(spec_insn_bge_valid, spec_insn_bge_valid, Mux(spec_insn_blt_valid, spec_insn_blt_valid, Mux(spec_insn_bne_valid, spec_insn_bne_valid, Mux(spec_insn_beq_valid, spec_insn_beq_valid, Mux(spec_insn_jalr_valid, spec_insn_jalr_valid, Mux(spec_insn_jal_valid, spec_insn_jal_valid, Mux(spec_insn_auipc_valid, spec_insn_auipc_valid, Mux(spec_insn_lui_valid, spec_insn_lui_valid, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_trap.eq(Mux(spec_insn_and_valid, spec_insn_and_trap, Mux(spec_insn_or_valid, spec_insn_or_trap, Mux(spec_insn_sra_valid, spec_insn_sra_trap, Mux(spec_insn_srl_valid, spec_insn_srl_trap, Mux(spec_insn_xor_valid, spec_insn_xor_trap, Mux(spec_insn_sltu_valid, spec_insn_sltu_trap, Mux(spec_insn_slt_valid, spec_insn_slt_trap, Mux(spec_insn_sll_valid, spec_insn_sll_trap, Mux(spec_insn_sub_valid, spec_insn_sub_trap, Mux(spec_insn_add_valid, spec_insn_add_trap, Mux(spec_insn_srai_valid, spec_insn_srai_trap, Mux(spec_insn_srli_valid, spec_insn_srli_trap, Mux(spec_insn_slli_valid, spec_insn_slli_trap, Mux(spec_insn_andi_valid, spec_insn_andi_trap, Mux(spec_insn_ori_valid, spec_insn_ori_trap, Mux(spec_insn_xori_valid, spec_insn_xori_trap, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_trap, Mux(spec_insn_slti_valid, spec_insn_slti_trap, Mux(spec_insn_addi_valid, spec_insn_addi_trap, Mux(spec_insn_sw_valid, spec_insn_sw_trap, Mux(spec_insn_sh_valid, spec_insn_sh_trap, Mux(spec_insn_sb_valid, spec_insn_sb_trap, Mux(spec_insn_lhu_valid, spec_insn_lhu_trap, Mux(spec_insn_lbu_valid, spec_insn_lbu_trap, Mux(spec_insn_lw_valid, spec_insn_lw_trap, Mux(spec_insn_lh_valid, spec_insn_lh_trap, Mux(spec_insn_lb_valid, spec_insn_lb_trap, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_trap, Mux(spec_insn_bltu_valid, spec_insn_bltu_trap, Mux(spec_insn_bge_valid, spec_insn_bge_trap, Mux(spec_insn_blt_valid, spec_insn_blt_trap, Mux(spec_insn_bne_valid, spec_insn_bne_trap, Mux(spec_insn_beq_valid, spec_insn_beq_trap, Mux(spec_insn_jalr_valid, spec_insn_jalr_trap, Mux(spec_insn_jal_valid, spec_insn_jal_trap, Mux(spec_insn_auipc_valid, spec_insn_auipc_trap, Mux(spec_insn_lui_valid, spec_insn_lui_trap, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_rs1_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rs1_addr, Mux(spec_insn_or_valid, spec_insn_or_rs1_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rs1_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rs1_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rs1_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rs1_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rs1_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rs1_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rs1_addr, Mux(spec_insn_add_valid, spec_insn_add_rs1_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rs1_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rs1_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rs1_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rs1_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rs1_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rs1_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rs1_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rs1_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rs1_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rs1_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rs1_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rs1_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rs1_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rs1_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rs1_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rs1_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rs1_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rs1_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rs1_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rs1_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rs1_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rs1_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rs1_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rs1_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rs1_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rs1_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rs1_addr, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_rs2_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rs2_addr, Mux(spec_insn_or_valid, spec_insn_or_rs2_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rs2_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rs2_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rs2_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rs2_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rs2_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rs2_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rs2_addr, Mux(spec_insn_add_valid, spec_insn_add_rs2_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rs2_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rs2_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rs2_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rs2_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rs2_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rs2_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rs2_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rs2_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rs2_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rs2_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rs2_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rs2_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rs2_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rs2_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rs2_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rs2_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rs2_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rs2_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rs2_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rs2_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rs2_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rs2_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rs2_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rs2_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rs2_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rs2_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rs2_addr, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_rd_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_rd_addr, Mux(spec_insn_or_valid, spec_insn_or_rd_addr, Mux(spec_insn_sra_valid, spec_insn_sra_rd_addr, Mux(spec_insn_srl_valid, spec_insn_srl_rd_addr, Mux(spec_insn_xor_valid, spec_insn_xor_rd_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_rd_addr, Mux(spec_insn_slt_valid, spec_insn_slt_rd_addr, Mux(spec_insn_sll_valid, spec_insn_sll_rd_addr, Mux(spec_insn_sub_valid, spec_insn_sub_rd_addr, Mux(spec_insn_add_valid, spec_insn_add_rd_addr, Mux(spec_insn_srai_valid, spec_insn_srai_rd_addr, Mux(spec_insn_srli_valid, spec_insn_srli_rd_addr, Mux(spec_insn_slli_valid, spec_insn_slli_rd_addr, Mux(spec_insn_andi_valid, spec_insn_andi_rd_addr, Mux(spec_insn_ori_valid, spec_insn_ori_rd_addr, Mux(spec_insn_xori_valid, spec_insn_xori_rd_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rd_addr, Mux(spec_insn_slti_valid, spec_insn_slti_rd_addr, Mux(spec_insn_addi_valid, spec_insn_addi_rd_addr, Mux(spec_insn_sw_valid, spec_insn_sw_rd_addr, Mux(spec_insn_sh_valid, spec_insn_sh_rd_addr, Mux(spec_insn_sb_valid, spec_insn_sb_rd_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_rd_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_rd_addr, Mux(spec_insn_lw_valid, spec_insn_lw_rd_addr, Mux(spec_insn_lh_valid, spec_insn_lh_rd_addr, Mux(spec_insn_lb_valid, spec_insn_lb_rd_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rd_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_rd_addr, Mux(spec_insn_bge_valid, spec_insn_bge_rd_addr, Mux(spec_insn_blt_valid, spec_insn_blt_rd_addr, Mux(spec_insn_bne_valid, spec_insn_bne_rd_addr, Mux(spec_insn_beq_valid, spec_insn_beq_rd_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_rd_addr, Mux(spec_insn_jal_valid, spec_insn_jal_rd_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_rd_addr, Mux(spec_insn_lui_valid, spec_insn_lui_rd_addr, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_rd_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_rd_wdata, Mux(spec_insn_or_valid, spec_insn_or_rd_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_rd_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_rd_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_rd_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_rd_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_rd_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_rd_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_rd_wdata, Mux(spec_insn_add_valid, spec_insn_add_rd_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_rd_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_rd_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_rd_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_rd_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_rd_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_rd_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_rd_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_rd_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_rd_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_rd_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_rd_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_rd_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_rd_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_rd_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_rd_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_rd_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_rd_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_rd_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_rd_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_rd_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_rd_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_rd_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_rd_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_rd_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_rd_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_rd_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_rd_wdata, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_pc_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_pc_wdata, Mux(spec_insn_or_valid, spec_insn_or_pc_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_pc_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_pc_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_pc_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_pc_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_pc_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_pc_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_pc_wdata, Mux(spec_insn_add_valid, spec_insn_add_pc_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_pc_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_pc_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_pc_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_pc_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_pc_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_pc_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_pc_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_pc_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_pc_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_pc_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_pc_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_pc_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_pc_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_pc_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_pc_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_pc_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_pc_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_pc_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_pc_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_pc_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_pc_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_pc_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_pc_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_pc_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_pc_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_pc_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_pc_wdata, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_mem_addr.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_addr, Mux(spec_insn_or_valid, spec_insn_or_mem_addr, Mux(spec_insn_sra_valid, spec_insn_sra_mem_addr, Mux(spec_insn_srl_valid, spec_insn_srl_mem_addr, Mux(spec_insn_xor_valid, spec_insn_xor_mem_addr, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_addr, Mux(spec_insn_slt_valid, spec_insn_slt_mem_addr, Mux(spec_insn_sll_valid, spec_insn_sll_mem_addr, Mux(spec_insn_sub_valid, spec_insn_sub_mem_addr, Mux(spec_insn_add_valid, spec_insn_add_mem_addr, Mux(spec_insn_srai_valid, spec_insn_srai_mem_addr, Mux(spec_insn_srli_valid, spec_insn_srli_mem_addr, Mux(spec_insn_slli_valid, spec_insn_slli_mem_addr, Mux(spec_insn_andi_valid, spec_insn_andi_mem_addr, Mux(spec_insn_ori_valid, spec_insn_ori_mem_addr, Mux(spec_insn_xori_valid, spec_insn_xori_mem_addr, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_addr, Mux(spec_insn_slti_valid, spec_insn_slti_mem_addr, Mux(spec_insn_addi_valid, spec_insn_addi_mem_addr, Mux(spec_insn_sw_valid, spec_insn_sw_mem_addr, Mux(spec_insn_sh_valid, spec_insn_sh_mem_addr, Mux(spec_insn_sb_valid, spec_insn_sb_mem_addr, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_addr, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_addr, Mux(spec_insn_lw_valid, spec_insn_lw_mem_addr, Mux(spec_insn_lh_valid, spec_insn_lh_mem_addr, Mux(spec_insn_lb_valid, spec_insn_lb_mem_addr, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_addr, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_addr, Mux(spec_insn_bge_valid, spec_insn_bge_mem_addr, Mux(spec_insn_blt_valid, spec_insn_blt_mem_addr, Mux(spec_insn_bne_valid, spec_insn_bne_mem_addr, Mux(spec_insn_beq_valid, spec_insn_beq_mem_addr, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_addr, Mux(spec_insn_jal_valid, spec_insn_jal_mem_addr, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_addr, Mux(spec_insn_lui_valid, spec_insn_lui_mem_addr, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_mem_rmask.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_rmask, Mux(spec_insn_or_valid, spec_insn_or_mem_rmask, Mux(spec_insn_sra_valid, spec_insn_sra_mem_rmask, Mux(spec_insn_srl_valid, spec_insn_srl_mem_rmask, Mux(spec_insn_xor_valid, spec_insn_xor_mem_rmask, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_rmask, Mux(spec_insn_slt_valid, spec_insn_slt_mem_rmask, Mux(spec_insn_sll_valid, spec_insn_sll_mem_rmask, Mux(spec_insn_sub_valid, spec_insn_sub_mem_rmask, Mux(spec_insn_add_valid, spec_insn_add_mem_rmask, Mux(spec_insn_srai_valid, spec_insn_srai_mem_rmask, Mux(spec_insn_srli_valid, spec_insn_srli_mem_rmask, Mux(spec_insn_slli_valid, spec_insn_slli_mem_rmask, Mux(spec_insn_andi_valid, spec_insn_andi_mem_rmask, Mux(spec_insn_ori_valid, spec_insn_ori_mem_rmask, Mux(spec_insn_xori_valid, spec_insn_xori_mem_rmask, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_rmask, Mux(spec_insn_slti_valid, spec_insn_slti_mem_rmask, Mux(spec_insn_addi_valid, spec_insn_addi_mem_rmask, Mux(spec_insn_sw_valid, spec_insn_sw_mem_rmask, Mux(spec_insn_sh_valid, spec_insn_sh_mem_rmask, Mux(spec_insn_sb_valid, spec_insn_sb_mem_rmask, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_rmask, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_rmask, Mux(spec_insn_lw_valid, spec_insn_lw_mem_rmask, Mux(spec_insn_lh_valid, spec_insn_lh_mem_rmask, Mux(spec_insn_lb_valid, spec_insn_lb_mem_rmask, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_rmask, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_rmask, Mux(spec_insn_bge_valid, spec_insn_bge_mem_rmask, Mux(spec_insn_blt_valid, spec_insn_blt_mem_rmask, Mux(spec_insn_bne_valid, spec_insn_bne_mem_rmask, Mux(spec_insn_beq_valid, spec_insn_beq_mem_rmask, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_rmask, Mux(spec_insn_jal_valid, spec_insn_jal_mem_rmask, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_rmask, Mux(spec_insn_lui_valid, spec_insn_lui_mem_rmask, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_mem_wmask.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_wmask, Mux(spec_insn_or_valid, spec_insn_or_mem_wmask, Mux(spec_insn_sra_valid, spec_insn_sra_mem_wmask, Mux(spec_insn_srl_valid, spec_insn_srl_mem_wmask, Mux(spec_insn_xor_valid, spec_insn_xor_mem_wmask, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_wmask, Mux(spec_insn_slt_valid, spec_insn_slt_mem_wmask, Mux(spec_insn_sll_valid, spec_insn_sll_mem_wmask, Mux(spec_insn_sub_valid, spec_insn_sub_mem_wmask, Mux(spec_insn_add_valid, spec_insn_add_mem_wmask, Mux(spec_insn_srai_valid, spec_insn_srai_mem_wmask, Mux(spec_insn_srli_valid, spec_insn_srli_mem_wmask, Mux(spec_insn_slli_valid, spec_insn_slli_mem_wmask, Mux(spec_insn_andi_valid, spec_insn_andi_mem_wmask, Mux(spec_insn_ori_valid, spec_insn_ori_mem_wmask, Mux(spec_insn_xori_valid, spec_insn_xori_mem_wmask, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_wmask, Mux(spec_insn_slti_valid, spec_insn_slti_mem_wmask, Mux(spec_insn_addi_valid, spec_insn_addi_mem_wmask, Mux(spec_insn_sw_valid, spec_insn_sw_mem_wmask, Mux(spec_insn_sh_valid, spec_insn_sh_mem_wmask, Mux(spec_insn_sb_valid, spec_insn_sb_mem_wmask, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_wmask, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_wmask, Mux(spec_insn_lw_valid, spec_insn_lw_mem_wmask, Mux(spec_insn_lh_valid, spec_insn_lh_mem_wmask, Mux(spec_insn_lb_valid, spec_insn_lb_mem_wmask, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_wmask, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_wmask, Mux(spec_insn_bge_valid, spec_insn_bge_mem_wmask, Mux(spec_insn_blt_valid, spec_insn_blt_mem_wmask, Mux(spec_insn_bne_valid, spec_insn_bne_mem_wmask, Mux(spec_insn_beq_valid, spec_insn_beq_mem_wmask, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_wmask, Mux(spec_insn_jal_valid, spec_insn_jal_mem_wmask, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_wmask, Mux(spec_insn_lui_valid, spec_insn_lui_mem_wmask, 0))))))))))))))))))))))))))))))))))))))
        m.d.comb += self.spec_mem_wdata.eq(Mux(spec_insn_and_valid, spec_insn_and_mem_wdata, Mux(spec_insn_or_valid, spec_insn_or_mem_wdata, Mux(spec_insn_sra_valid, spec_insn_sra_mem_wdata, Mux(spec_insn_srl_valid, spec_insn_srl_mem_wdata, Mux(spec_insn_xor_valid, spec_insn_xor_mem_wdata, Mux(spec_insn_sltu_valid, spec_insn_sltu_mem_wdata, Mux(spec_insn_slt_valid, spec_insn_slt_mem_wdata, Mux(spec_insn_sll_valid, spec_insn_sll_mem_wdata, Mux(spec_insn_sub_valid, spec_insn_sub_mem_wdata, Mux(spec_insn_add_valid, spec_insn_add_mem_wdata, Mux(spec_insn_srai_valid, spec_insn_srai_mem_wdata, Mux(spec_insn_srli_valid, spec_insn_srli_mem_wdata, Mux(spec_insn_slli_valid, spec_insn_slli_mem_wdata, Mux(spec_insn_andi_valid, spec_insn_andi_mem_wdata, Mux(spec_insn_ori_valid, spec_insn_ori_mem_wdata, Mux(spec_insn_xori_valid, spec_insn_xori_mem_wdata, Mux(spec_insn_sltiu_valid, spec_insn_sltiu_mem_wdata, Mux(spec_insn_slti_valid, spec_insn_slti_mem_wdata, Mux(spec_insn_addi_valid, spec_insn_addi_mem_wdata, Mux(spec_insn_sw_valid, spec_insn_sw_mem_wdata, Mux(spec_insn_sh_valid, spec_insn_sh_mem_wdata, Mux(spec_insn_sb_valid, spec_insn_sb_mem_wdata, Mux(spec_insn_lhu_valid, spec_insn_lhu_mem_wdata, Mux(spec_insn_lbu_valid, spec_insn_lbu_mem_wdata, Mux(spec_insn_lw_valid, spec_insn_lw_mem_wdata, Mux(spec_insn_lh_valid, spec_insn_lh_mem_wdata, Mux(spec_insn_lb_valid, spec_insn_lb_mem_wdata, Mux(spec_insn_bgeu_valid, spec_insn_bgeu_mem_wdata, Mux(spec_insn_bltu_valid, spec_insn_bltu_mem_wdata, Mux(spec_insn_bge_valid, spec_insn_bge_mem_wdata, Mux(spec_insn_blt_valid, spec_insn_blt_mem_wdata, Mux(spec_insn_bne_valid, spec_insn_bne_mem_wdata, Mux(spec_insn_beq_valid, spec_insn_beq_mem_wdata, Mux(spec_insn_jalr_valid, spec_insn_jalr_mem_wdata, Mux(spec_insn_jal_valid, spec_insn_jal_mem_wdata, Mux(spec_insn_auipc_valid, spec_insn_auipc_mem_wdata, Mux(spec_insn_lui_valid, spec_insn_lui_mem_wdata, 0))))))))))))))))))))))))))))))))))))))

        return m