diff --git a/.scalafmt.conf b/.scalafmt.conf
deleted file mode 100644
index cbc03c3..0000000
--- a/.scalafmt.conf
+++ /dev/null
@@ -1,2 +0,0 @@
-version = 3.7.17
-runner.dialect = scala213source3
diff --git a/flake.nix b/flake.nix
index 5c9c6f7..74de402 100644
--- a/flake.nix
+++ b/flake.nix
@@ -50,13 +50,6 @@
                 enable = true;
                 types_or = pkgs.lib.mkForce [ "c" "c++" ];
               };
-              scalafmt = {
-                enable = true;
-                package = pkgs.scalafmt;
-                name = "Scalafmt";
-                types = [ "scala" ];
-                entry = "${pkgs.scalafmt}/bin/scalafmt --non-interactive";
-              };
             };
           };
         };
diff --git a/npc/core/build.sbt b/npc/core/build.sbt
index e5de39d..3d0f4f8 100644
--- a/npc/core/build.sbt
+++ b/npc/core/build.sbt
@@ -1,8 +1,9 @@
-ThisBuild / scalaVersion := "2.13.12"
-ThisBuild / version := "0.1.0"
+ThisBuild / scalaVersion     := "2.13.12"
+ThisBuild / version          := "0.1.0"
+
 
 val chiselVersion = "6.2.0"
-val circeVersion = "0.14.1"
+val circeVersion  = "0.14.1"
 
 lazy val root = (project in file("."))
   .settings(
@@ -11,7 +12,7 @@ lazy val root = (project in file("."))
       "org.chipsalliance" %% "chisel" % chiselVersion,
       "edu.berkeley.cs" %% "chiseltest" % "6.0.0" % "test",
       "com.chuusai" %% "shapeless" % "2.3.3",
-      "com.github.scopt" %% "scopt" % "4.1.0"
+      "com.github.scopt" %% "scopt" % "4.1.0",
     ) ++ Seq(
       "io.circe" %% "circe-core",
       "io.circe" %% "circe-generic",
@@ -22,9 +23,7 @@ lazy val root = (project in file("."))
       "-deprecation",
       "-feature",
       "-Xcheckinit",
-      "-Ymacro-annotations"
+      "-Ymacro-annotations",
     ),
-    addCompilerPlugin(
-      "org.chipsalliance" % "chisel-plugin" % chiselVersion cross CrossVersion.full
-    )
-  )
+    addCompilerPlugin("org.chipsalliance" % "chisel-plugin" % chiselVersion cross CrossVersion.full),
+  )
\ No newline at end of file
diff --git a/npc/core/src/main/scala/components/CSR.scala b/npc/core/src/main/scala/components/CSR.scala
deleted file mode 100644
index 5ea795f..0000000
--- a/npc/core/src/main/scala/components/CSR.scala
+++ /dev/null
@@ -1,108 +0,0 @@
-package flow.components
-
-import chisel3._
-import chisel3.util.log2Ceil
-import scala.reflect.runtime.universe._
-import cats.instances.MapInstances
-import dataclass.data
-import chisel3.util.experimental.decode.{decoder, TruthTable}
-import shapeless.HNil
-import flow.Params
-import chisel3.util.BitPat
-import chisel3.util.Fill
-
-class CSRControlInterface extends Bundle {
-  object csrRead extends ChiselEnum {
-    val csrReadDisabled, csrReadEnabled = Value
-  }
-
-  object csrWrite extends ChiselEnum {
-    val csrWriteDisabled, csrWriteEnabled = Value
-  }
-
-  val readEnable = Input(csrRead())
-  val writeEnable = Input(csrWrite())
-
-  def ctrlBindPorts = {
-    readEnable :: writeEnable :: HNil
-  }
-}
-
-class CSRCore(implicit val p: Params) extends Module {
-  val control = IO(new CSRControlInterface)
-
-  val in = IO(new Bundle {
-    val csrAddr = Input(UInt(p.csrAddrWidth))
-    val writeData = Input(UInt(p.XLEN))
-  })
-
-  val out = IO(new Bundle {
-    val readData = Output(UInt(p.XLEN))
-    val readValid = Output(Bool())
-  })
-
-  implicit class fromChiselEnumToBool[T <: EnumType](x: T) {
-    def B: Bool = {
-      x.asUInt =/= 0.U
-    }
-  }
-
-  val nameToAddr = Map(
-    "mstatus" -> 0x300,
-    "mtvec" -> 0x305,
-    "mie" -> 0x304,
-    "mepc" -> 0x341,
-    "mcause" -> 0x342,
-    "mtval" -> 0x343,
-    "mip" -> 0x344
-  )
-  val csrSize = nameToAddr.size
-
-  val addrToIndex = nameToAddr.zipWithIndex
-    .map(x => {
-      val (name: String, csrAddr: Int) = x._1
-      val index = x._2
-
-      csrAddr -> index
-    })
-    .toMap
-  val indexToAddr = addrToIndex.map(_.swap)
-
-  val csrIndexWidth = log2Ceil(csrSize).W
-
-  private val align = (x: UInt, w: Width) => BitPat(x.litValue.U(w))
-  val csrIndex = decoder(
-    in.csrAddr,
-    TruthTable(
-      addrToIndex.map(x =>
-        // Addr                              Index
-        (align(x._1.U, p.csrAddrWidth), align(x._2.U, csrIndexWidth))
-      ),
-      align(addrToIndex.head._2.U, csrIndexWidth)
-    )
-  )
-
-  val csrIndexValid = !(
-    csrIndex === BitPat(0.U) &&
-      in.csrAddr =/= align(indexToAddr(0).U, p.csrAddrWidth)
-  )
-
-  val regs = RegInit(VecInit(Seq.fill(csrSize)(0.U(p.XLEN))))
-
-  val regReadValue = regs(csrIndex)
-
-  val delayWriteData = RegNext(in.writeData, 0.U(p.XLEN))
-  val delayWriteEnable = RegNext(control.writeEnable)
-
-  when(control.writeEnable.B) {
-    regs(csrIndex) := delayWriteData
-  }
-
-  when(control.readEnable.B) {
-    out.readData := regReadValue
-    out.readValid := true.B && csrIndexValid
-  } otherwise {
-    out.readData := 0.U(p.XLEN)
-    out.readValid := false.B && csrIndexValid
-  }
-}
diff --git a/npc/core/src/main/scala/components/Mem.scala b/npc/core/src/main/scala/components/Mem.scala
index 52889cb..a9d3e22 100644
--- a/npc/core/src/main/scala/components/Mem.scala
+++ b/npc/core/src/main/scala/components/Mem.scala
@@ -24,8 +24,7 @@ class RamControlInterface(addrWidth: Int) extends Bundle {
 /* FIXME: Extends here might not be the best solution.
  *        We need a way to merge two bundles together
  */
-class RamInterface[T <: Data](tpe: T, addrWidth: Int)
-    extends RamControlInterface(addrWidth) {
+class RamInterface[T <: Data](tpe: T, addrWidth: Int) extends RamControlInterface(addrWidth) {
   val clock = Input(Clock())
   val reset = Input(Reset())
   val writeAddr = Input(UInt(addrWidth.W))
diff --git a/npc/core/src/main/scala/components/ProgramCounter.scala b/npc/core/src/main/scala/components/ProgramCounter.scala
index 287ca7f..01ac115 100644
--- a/npc/core/src/main/scala/components/ProgramCounter.scala
+++ b/npc/core/src/main/scala/components/ProgramCounter.scala
@@ -30,11 +30,11 @@ class ProgramCounter[T <: UInt](tpe: T) extends Module {
 
 //   pc := in.pcSrcs(control.srcSelect.asUInt)
   import control.SrcSelect._
-  when(control.useImmB === true.B) {
+  when( control.useImmB === true.B ) {
     pc_reg := pc_reg + in.immB
-  }.elsewhen(control.srcSelect === pStaticNpc) {
+  }. elsewhen( control.srcSelect === pStaticNpc) {
     pc_reg := pc_reg + 4.U
-  }.elsewhen(control.srcSelect === pExeOut) {
+  }. elsewhen( control.srcSelect === pExeOut) {
     pc_reg := in.exeOut
   }
   out := pc_reg
diff --git a/npc/core/src/main/scala/components/RegisterFile.scala b/npc/core/src/main/scala/components/RegisterFile.scala
index fe646fd..b5d1b63 100644
--- a/npc/core/src/main/scala/components/RegisterFile.scala
+++ b/npc/core/src/main/scala/components/RegisterFile.scala
@@ -5,7 +5,7 @@ import chisel3.util.log2Ceil
 import chisel3.util.UIntToOH
 import chisel3.util.MuxLookup
 import chisel3.experimental.Trace._
-import shapeless.{HList, HNil, ::}
+import shapeless.{ HList, HNil, :: }
 
 class RegControl extends Bundle {
   object WriteSelect extends ChiselEnum {
@@ -21,8 +21,7 @@ class RegControl extends Bundle {
   traceName(writeEnable)
 }
 
-class RegisterFile[T <: Data](tpe: T, regCount: Int, numReadPorts: Int)
-    extends Module {
+class RegisterFile[T <: Data](tpe: T, regCount: Int, numReadPorts: Int) extends Module {
   require(numReadPorts >= 0)
   val control = IO(new RegControl)
   val dataAddrWidth = log2Ceil(regCount).W
@@ -41,10 +40,7 @@ class RegisterFile[T <: Data](tpe: T, regCount: Int, numReadPorts: Int)
 
   for ((reg, i) <- regFile.zipWithIndex.tail) {
     reg := Mux(
-      writeAddrOH(i.U(log2Ceil(regCount).W)) && control.writeEnable,
-      in.writeData(control.writeSelect.asUInt),
-      reg
-    )
+      writeAddrOH(i.U(log2Ceil(regCount).W)) && control.writeEnable, in.writeData(control.writeSelect.asUInt), reg)
   }
   regFile(0) := 0.U
 
diff --git a/npc/core/src/main/scala/top/ArgParse.scala b/npc/core/src/main/scala/top/ArgParse.scala
index 1b8cf41..b430a70 100644
--- a/npc/core/src/main/scala/top/ArgParse.scala
+++ b/npc/core/src/main/scala/top/ArgParse.scala
@@ -1,16 +1,16 @@
 package flow
 
-import scopt.{OParser, DefaultOEffectSetup}
+import scopt.{ OParser, DefaultOEffectSetup }
 import java.io.File
 
 case class CliOptions(
     targetDir: File = new File("."),
     configFile: Option[File] = None,
     argsFile: Option[File] = None,
-    verilatorConfigFileOut: File = new File("conf.vlt")
+    verilatorConfigFileOut: File = new File("conf.vlt"),
 ) {
   val builder = OParser.builder[CliOptions]
-  val parser = {
+  val parser =  {
     import builder._
     OParser.sequence(
       programName("flow"),
@@ -33,19 +33,14 @@ case class CliOptions(
   def parse(args: Array[String]): CliOptions = {
     OParser.runParser(parser, args, CliOptions()) match {
       case (result, effects) =>
-        OParser.runEffects(
-          effects,
-          new DefaultOEffectSetup {
-            // ignore terminate
-            override def terminate(exitState: Either[String, Unit]): Unit = ()
-          }
-        )
+        OParser.runEffects(effects, new DefaultOEffectSetup {
+          // ignore terminate
+          override def terminate(exitState: Either[String, Unit]): Unit = ()
+        })
 
         result match {
           case Some(cliOptions: CliOptions) => { return cliOptions }
-          case _ => {
-            throw new IllegalArgumentException("Wrong command line argument")
-          }
+          case _ => { throw new IllegalArgumentException("Wrong command line argument") }
         }
     }
   }
diff --git a/npc/core/src/main/scala/top/Config.scala b/npc/core/src/main/scala/top/Config.scala
index d2f3a2e..aa58107 100644
--- a/npc/core/src/main/scala/top/Config.scala
+++ b/npc/core/src/main/scala/top/Config.scala
@@ -3,20 +3,14 @@ package flow
 import io.circe.generic.JsonCodec
 
 // Which group of signals to trace
-@JsonCodec case class TraceConfig(
-    enable: Boolean = false,
-    registers: Array[Int] = Array(),
-    mem: Array[(Int, Int)] = Array()
+@JsonCodec case class TraceConfig (
+  enable: Boolean = false,
+  registers: Array[Int] = Array(),
+  mem: Array[(Int, Int)] = Array(),
 )
 
 @JsonCodec case class Config(
-    // Whether to enable Difftest
-    enableDifftest: Boolean = true,
-    traceConfig: TraceConfig = TraceConfig()
-)
-
-import chisel3._
-case class Params(
-    XLEN: Width,
-    csrAddrWidth: Width = 12.W
+  // Whether to enable Difftest
+  enableDifftest: Boolean = true,
+  traceConfig: TraceConfig = TraceConfig(),
 )
diff --git a/npc/core/src/main/scala/top/FlowMain.scala b/npc/core/src/main/scala/top/FlowMain.scala
index edce4d4..3377689 100644
--- a/npc/core/src/main/scala/top/FlowMain.scala
+++ b/npc/core/src/main/scala/top/FlowMain.scala
@@ -8,7 +8,7 @@ import chisel3.experimental.Trace._
 import shapeless.{HNil, ::}
 import shapeless.HList
 import shapeless.ops.coproduct.Prepend
-import chisel3.util.{BinaryMemoryFile, HexMemoryFile}
+import chisel3.util.{ BinaryMemoryFile, HexMemoryFile }
 
 import chisel3.experimental.Trace
 import scala.collection.IndexedSeqView
@@ -18,7 +18,6 @@ import flow.components.RamControlInterface
 object RV32Inst {
   private val bp = BitPat
 
-  // format: off
   val lui    = this.bp("b???????_?????_?????_???_?????_01101_11")
   val auipc  = this.bp("b???????_?????_?????_???_?????_00101_11")
 
@@ -73,33 +72,28 @@ object RV32Inst {
   val remu   = this.bp("b0000001_?????_?????_111_?????_01100_11")
 
   val inv    = this.bp("b???????_?????_?????_???_?????_?????_??")
-  // format: on
 }
 
 import flow.components.{RegControl, PcControlInterface, ALUControlInterface}
 class Control(width: Int) extends RawModule {
   // Helpers
-  class WrapList[T](vl: T) { type Type = T; val v = vl }
+  class WrapList[T](vl: T) { type Type = T; val v = vl}
   object wrap extends Poly1 {
     implicit def default[A] = at[A](Right(_).withLeft[Int])
   }
   def lit(x: Element) = { x.litValue.toInt }
   def toBits(t: dst.Type): BitPat = {
     val list = t.toList
-    list
-      .map(e =>
-        e match {
-          case Right(x) => BitPat(lit(x).U(x.getWidth.W))
-          case Left(x)  => BitPat.dontCare(x)
-        }
-      )
-      .reduceLeft(_ ## _)
+    list.map(e => e match {
+      case Right(x) => BitPat(lit(x).U(x.getWidth.W))
+      case Left(x) => BitPat.dontCare(x)
+    }).reduceLeft(_ ## _)
   }
   val r = Right
   def l[T <: Any](x: T) = x match {
     case x: ChiselEnum => Left(log2Ceil(x.all.length))
-    case x: Data       => Left(x.getWidth)
-    case _             => throw new IllegalArgumentException
+    case x: Data => Left(x.getWidth)
+    case _ => throw new IllegalArgumentException
   }
 
   val inst = IO(Input(UInt(width.W)))
@@ -109,12 +103,11 @@ class Control(width: Int) extends RawModule {
   val alu = IO(Flipped(new ALUControlInterface))
   val ram = IO(Flipped(new RamControlInterface(32)))
 
-  val dst = new WrapList(
-    (reg.ctrlBindPorts ++
-      pc.ctrlBindPorts ++
-      alu.ctrlBindPorts ++
-      ram.ctrlBindPorts).map(wrap)
-  )
+  val dst = new WrapList((
+    reg.ctrlBindPorts ++
+    pc.ctrlBindPorts ++
+    alu.ctrlBindPorts ++
+    ram.ctrlBindPorts).map(wrap))
 
   val dstList = dst.v.toList
   val controlWidth = dstList.map(_.toOption.get.getWidth).reduce(_ + _)
@@ -131,286 +124,209 @@ class Control(width: Int) extends RawModule {
   import alu.SrcBSelect._
   import pc._
   import RV32Inst._
-  // format: off
   val ControlMapping: Array[(BitPat, dst.Type)] = Array(
     //     Regs | writeEnable :: writeSelect :: HNil
     //     PC   | useImmB :: srcSelect :: HNil
     //     Exe  | op :: srcASelect :: srcBSelect :: signExt :: HNil
     //     Mem  | valid :: writeMask :: writeEnable :: HNil
 
-    (lui   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc)::
-      r(aOpAdd)     :: r(aSrcAZero)  :: r(aSrcBImmU) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (lui   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc)::
+              r(aOpAdd)     :: r(aSrcAZero)  :: r(aSrcBImmU) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (auipc , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc)::
-      r(aOpAdd)     :: r(aSrcAPc)  :: r(aSrcBImmU) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (auipc , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc)::
+              r(aOpAdd)     :: r(aSrcAPc)  :: r(aSrcBImmU) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
     // ---- Control Transfer Instructions ----
-    (jal   , (
-      r(true.B)     :: r(rNpc)     ::
-      r(false.B)    :: r(pExeOut)  ::
-      r(aOpAdd)     :: r(aSrcAPc)  :: r(aSrcBImmJ) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (jal   , (r(true.B)     :: r(rNpc)     ::
+              r(false.B)    :: r(pExeOut)  ::
+              r(aOpAdd)     :: r(aSrcAPc)  :: r(aSrcBImmJ) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (jalr  , (
-      r(true.B)     :: r(rNpc)     ::
-      r(false.B)    :: r(pExeOut)    ::
-      r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (jalr  , (r(true.B)     :: r(rNpc)     ::
+              r(false.B)    :: r(pExeOut)    ::
+              r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (beq   , (
-      r(false.B)    :: l(WriteSelect) ::
-      r(true.B)     :: r(pStaticNpc)     ::
-      r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: l(Bool())    ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (beq   , (r(false.B)    :: l(WriteSelect) ::
+              r(true.B)     :: r(pStaticNpc)     ::
+              r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: l(Bool())    ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (bne   , (
-      r(false.B)    :: l(WriteSelect) ::
-      r(true.B)     :: r(pStaticNpc)     ::
-      r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: l(Bool())    ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (bne   , (r(false.B)    :: l(WriteSelect) ::
+              r(true.B)     :: r(pStaticNpc)     ::
+              r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: l(Bool())    ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (blt   , (
-      r(false.B)    :: l(WriteSelect) ::
-      r(true.B)     :: r(pStaticNpc)     ::
-      r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: r(true.B)  ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (blt   , (r(false.B)    :: l(WriteSelect) ::
+              r(true.B)     :: r(pStaticNpc)     ::
+              r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: r(true.B)  ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (bge   , (
-      r(false.B)    :: l(WriteSelect) ::
-      r(true.B)     :: r(pStaticNpc)     ::
-      r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: r(true.B)  ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (bge   , (r(false.B)    :: l(WriteSelect) ::
+              r(true.B)     :: r(pStaticNpc)     ::
+              r(aOpSlt)     :: r(aSrcARs1)  :: r(aSrcBRs2) :: r(true.B)  ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (bltu  , (
-      r(false.B)    :: l(WriteSelect)::
-      r(true.B)     :: r(pStaticNpc)    ::
-      r(aOpSltu)     :: r(aSrcARs1)    :: r(aSrcBRs2) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W))  :: r(false.B)   :: HNil
-    )),
+    (bltu  , (r(false.B)    :: l(WriteSelect)::
+              r(true.B)     :: r(pStaticNpc)    ::
+              r(aOpSltu)     :: r(aSrcARs1)    :: r(aSrcBRs2) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W))  :: r(false.B)   :: HNil)),
 
-    (bgeu  , (
-      r(false.B)    :: l(WriteSelect)::
-      r(true.B)     :: r(pStaticNpc)    ::
-      r(aOpSltu)     :: r(aSrcARs1)    :: r(aSrcBRs2) :: r(false.B) ::
-      r(false.B)    :: l(UInt(4.W))  :: r(false.B)   :: HNil
-    )),
+    (bgeu  , (r(false.B)    :: l(WriteSelect)::
+              r(true.B)     :: r(pStaticNpc)    ::
+              r(aOpSltu)     :: r(aSrcARs1)    :: r(aSrcBRs2) :: r(false.B) ::
+              r(false.B)    :: l(UInt(4.W))  :: r(false.B)   :: HNil)),
 
     // ---- Memory Access Instructions ----
 
-    (lb    , (
-      r(true.B)     :: r(rMemOut)    ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
-      r(true.B)     :: r(1.U(4.W))  :: r(false.B)   :: HNil
-    )),
+    (lb    , (r(true.B)     :: r(rMemOut)    ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
+              r(true.B)     :: r(1.U(4.W))  :: r(false.B)   :: HNil)),
 
-    (lbu   , (
-      r(true.B)    :: r(rMemOut)    ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
-      r(true.B)     :: r(0.U(4.W))  :: r(false.B)   :: HNil
-    )),
+    (lbu    , (r(true.B)    :: r(rMemOut)    ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
+              r(true.B)     :: r(0.U(4.W))  :: r(false.B)   :: HNil)),
 
-    (lh     , (
-      r(true.B)    :: r(rMemOut)    ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
-      r(true.B)     :: r(3.U(4.W))  :: r(false.B)   :: HNil
-    )),
+    (lh     , (r(true.B)    :: r(rMemOut)    ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
+              r(true.B)     :: r(3.U(4.W))  :: r(false.B)   :: HNil)),
 
-    (lhu    , (
-      r(true.B)    :: r(rMemOut)    ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
-      r(true.B)     :: r(2.U(4.W))  :: r(false.B)   :: HNil
-    )),
+    (lhu    , (r(true.B)    :: r(rMemOut)    ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
+              r(true.B)     :: r(2.U(4.W))  :: r(false.B)   :: HNil)),
 
-    (lw    , (
-      r(true.B)     :: r(rMemOut)    ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
-      r(true.B)     :: r(14.U(4.W))  :: r(false.B)   :: HNil
-    )),
+    (lw    , (r(true.B)     :: r(rMemOut)    ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmI) :: l(Bool()) ::
+              r(true.B)     :: r(14.U(4.W))  :: r(false.B)   :: HNil)),
 
-    (sb    , (
-      r(false.B)    :: l(WriteSelect)::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
-      r(true.B)     :: r(1.U(4.W))   :: r(true.B)   :: HNil
-    )),
+    (sb    , (r(false.B)    :: l(WriteSelect)::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
+              r(true.B)     :: r(1.U(4.W))   :: r(true.B)   :: HNil)),
 
-    (sh    , (
-      r(false.B)    :: l(WriteSelect)::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
-      r(true.B)     :: r(3.U(4.W))   :: r(true.B)   :: HNil
-    )),
+    (sh    , (r(false.B)    :: l(WriteSelect)::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
+              r(true.B)     :: r(3.U(4.W))   :: r(true.B)   :: HNil)),
 
-    (sw    , (
-      r(false.B)    :: l(WriteSelect)::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
-      r(true.B)     :: r(15.U(4.W))  :: r(true.B)   :: HNil
-    )),
+    (sw    , (r(false.B)    :: l(WriteSelect)::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1)   :: r(aSrcBImmS) :: l(Bool()) ::
+              r(true.B)     :: r(15.U(4.W))  :: r(true.B)   :: HNil)),
 
     // ---- Integer Computational Instructions ---
 
-    (addi  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (addi  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)    :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (slti  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSlt)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(true.B)  ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (slti  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSlt)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(true.B)  ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (sltiu , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSltu)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(false.B) ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (sltiu , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSltu)     :: r(aSrcARs1) :: r(aSrcBImmI) :: r(false.B) ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (xori  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpXor)      :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (xori  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpXor)      :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (ori   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpOr)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (ori   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpOr)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (andi  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAnd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (andi  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAnd)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (slli  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSll)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (slli  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSll)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (srli  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSrl)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (srli  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSrl)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (srai  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSra)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (srai  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSra)     :: r(aSrcARs1) :: r(aSrcBImmI) :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (add   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (add   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAdd)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (sub   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSub)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (sub   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSub)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (sll   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSll)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (sll   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSll)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (slt   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSlt)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: r(true.B)  ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (slt   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSlt)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: r(true.B)  ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (sltu  , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSltu)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: r(false.B) ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (sltu  , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSltu)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: r(false.B) ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (xor   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpXor)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (xor   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpXor)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (srl   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSrl)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (srl   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSrl)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (sra   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpSra)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (sra   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpSra)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (or    , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpOr)      :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (or    , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpOr)      :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
 
-    (and   , (
-      r(true.B)     :: r(rAluOut)  ::
-      r(false.B)    :: r(pStaticNpc) ::
-      r(aOpAnd)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
-      r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil
-    )),
+    (and   , (r(true.B)     :: r(rAluOut)  ::
+              r(false.B)    :: r(pStaticNpc) ::
+              r(aOpAnd)     :: r(aSrcARs1) :: r(aSrcBRs2)  :: l(Bool())    ::
+              r(false.B)     :: l(UInt(4.W)):: r(false.B)   :: HNil)),
   )
-  // format: on
 
   val default = BitPat(0.U(controlWidth.W))
 
 //   println(s"ControlMapping = ${ControlMapping.map(it => (it._1 -> toBits(it._2))).foreach(x => println(x._2))}\n")
   val out = decoder(
     inst,
-    TruthTable(ControlMapping.map(it => (it._1 -> toBits(it._2))), default)
-  )
+    TruthTable(ControlMapping.map(it => (it._1 -> toBits(it._2))), default))
   val srcList = slices.map(s => out(s._1, s._2))
 
   assert(out != default)
@@ -447,13 +363,7 @@ class Flow extends Module {
   val npc = Wire(dataType)
   npc := pc.out + 4.U
   pc.in.exeOut := alu.out.result
-  pc.in.immB := Cat(
-    Fill(20, inst(31)),
-    inst(7),
-    inst(30, 25),
-    inst(11, 8),
-    0.U(1.W)
-  )
+  pc.in.immB := Cat(Fill(20, inst(31)), inst(7), inst(30, 25), inst(11, 8), 0.U(1.W))
 
   control.inst := inst
   reg.control <> control.reg
@@ -477,8 +387,7 @@ class Flow extends Module {
     Fill(8, ram.io.writeMask(3)),
     Fill(8, ram.io.writeMask(2)),
     Fill(8, ram.io.writeMask(1)),
-    "b11111111".U
-  )
+    "b11111111".U)
 
   val doSignExt = control.ram.writeMask(0)
   val signExt16 = control.ram.writeMask(1)
@@ -486,14 +395,10 @@ class Flow extends Module {
     reg.in.writeData(lit(rMemOut)) := maskedData
     // printf(cf"!doSignExt\n")
   }.elsewhen(signExt16) {
-    reg.in.writeData(lit(rMemOut)) := Cat(
-      Fill(16, maskedData(15)),
-      maskedData(15, 0)
-    )
+    reg.in.writeData(lit(rMemOut)) := Cat(Fill(16, maskedData(15)), maskedData(15, 0))
     // printf(cf"elsewhen\n")
   }.otherwise {
-    reg.in
-      .writeData(lit(rMemOut)) := Cat(Fill(24, maskedData(7)), maskedData(7, 0))
+    reg.in.writeData(lit(rMemOut)) := Cat(Fill(24, maskedData(7)), maskedData(7, 0))
     // printf(cf"otherwise\n")
   }
   // printf(cf"maskedData = ${maskedData}, writeData = ${reg.in.writeData(lit(rMemOut))}\n")
@@ -522,21 +427,8 @@ class Flow extends Module {
   alu.in.b(lit(aSrcBRs2)) := reg.out.src(1)
   // alu.in.b(lit(aSrcBImmI)) := inst(31, 20).pad(aSrcBImmI.getWidth)
   alu.in.b(lit(aSrcBImmI)) := Cat(Fill(20, inst(31)), inst(31, 20))
-  alu.in.b(lit(aSrcBImmJ)) := Cat(
-    Fill(12, inst(31)),
-    inst(19, 12),
-    inst(20),
-    inst(30, 25),
-    inst(24, 21),
-    0.U(1.W)
-  )
-  alu.in.b(lit(aSrcBImmS)) := Cat(
-    Fill(20, inst(31)),
-    inst(31),
-    inst(30, 25),
-    inst(11, 8),
-    inst(7)
-  )
+  alu.in.b(lit(aSrcBImmJ)) := Cat(Fill(12, inst(31)), inst(19, 12), inst(20), inst(30, 25), inst(24, 21), 0.U(1.W))
+  alu.in.b(lit(aSrcBImmS)) := Cat(Fill(20, inst(31)), inst(31), inst(30, 25), inst(11, 8), inst(7))
   alu.in.b(lit(aSrcBImmU)) := Cat(inst(31, 12), 0.U(12.W))
 
   Trace.traceName(pc.out)
diff --git a/npc/core/src/main/scala/top/Main.scala b/npc/core/src/main/scala/top/Main.scala
index ba4ce99..6de6893 100644
--- a/npc/core/src/main/scala/top/Main.scala
+++ b/npc/core/src/main/scala/top/Main.scala
@@ -13,6 +13,7 @@ import java.io.PrintWriter
 import scala.io.Source
 import java.io.File
 
+
 // TODO: Generate verilator config file
 
 object VerilogMain extends App {
@@ -26,58 +27,46 @@ object VerilogMain extends App {
       source.close()
       io.circe.parser.decode[Config](jsonString) match {
         case Right(x) => x
-        case Left(e)  => throw e
+        case Left(e) => throw e
       }
     }
     case None => Config(traceConfig = TraceConfig(enable = true))
   }
 
   val annos = (new ChiselStage).execute(
-    Array(
-      "--target-dir",
-      opt.targetDir.toString,
-      "--target",
-      "systemverilog",
-      "--split-verilog",
-      "--full-stacktrace"
-    ),
+    Array("--target-dir", opt.targetDir.toString, "--target", "systemverilog", "--split-verilog", "--full-stacktrace"),
     Seq(
-    ) ++ (if (config.traceConfig.enable)
-            Seq(ChiselGeneratorAnnotation(() => new Flow))
-          else Seq())
+
+    ) ++ (if(config.traceConfig.enable) Seq(ChiselGeneratorAnnotation(() => new Flow)) else Seq())
   )
 
-  if (config.traceConfig.enable) {
-    val dut = annos
-      .collectFirst { case DesignAnnotation(dut) => dut }
-      .get
-      .asInstanceOf[Flow]
+  if(config.traceConfig.enable) {
+    val dut = annos.collectFirst { case DesignAnnotation(dut) => dut }.get.asInstanceOf[Flow]
 
-    val verilatorConfigSeq = finalTargetMap(annos).values.flatten
+    val verilatorConfigSeq = finalTargetMap(annos)
+      .values
+      .flatten
       .map(ct =>
-        s"""public_flat_rd -module "${ct.tokens.collectFirst {
-            case OfModule(m) => m
-          }.get}" -var "${ct.tokens.collectFirst { case Ref(r) => r }.get}""""
-      )
-    finalTargetMap(annos).values.flatten
-      .foreach(ct =>
-        println(s"""TOP.${ct.circuit}.${ct.path
-            .map { case (Instance(i), _) => i }
-            .mkString(".")}.${ct.tokens.collectFirst { case Ref(r) =>
-            r
-          }.get}""")
+        s"""public_flat_rd -module "${
+          ct.tokens.collectFirst { case OfModule(m) => m }.get
+        }" -var "${ct.tokens.collectFirst { case Ref(r) => r }.get}"""")
+    finalTargetMap(annos)
+      .values
+      .flatten
+      .foreach(
+        ct => println(s"""TOP.${ct.circuit}.${ct.path.map { case (Instance(i), _) => i }.mkString(".")}.${ct.tokens.collectFirst {
+          case Ref(r) => r
+        }.get}""")
       )
 
-    val verilatorConfigWriter = new PrintWriter(
-      new File(opt.targetDir, opt.verilatorConfigFileOut.toString())
-    )
+    val verilatorConfigWriter = new PrintWriter(new File(opt.targetDir, opt.verilatorConfigFileOut.toString()))
     verilatorConfigWriter.write("`verilator_config\n")
     try {
-      for (ct <- verilatorConfigSeq) {
+      for(ct <- verilatorConfigSeq) {
         verilatorConfigWriter.println(ct)
       }
     } finally {
       verilatorConfigWriter.close()
     }
   }
-}
+}
\ No newline at end of file
diff --git a/npc/core/src/main/scala/utils/Keyboard.scala b/npc/core/src/main/scala/utils/Keyboard.scala
index fd37a9c..716c304 100644
--- a/npc/core/src/main/scala/utils/Keyboard.scala
+++ b/npc/core/src/main/scala/utils/Keyboard.scala
@@ -55,7 +55,7 @@ class KeyboardController extends Module {
 }
 
 class KeyboardSegController extends Module {
-  val io = IO(new Bundle {
+  val io = IO(new Bundle{
     val keycode = Flipped(Decoupled(UInt(8.W)))
     val segs = Vec(8, UInt(8.W))
   })
@@ -66,60 +66,30 @@ class KeyboardSegController extends Module {
 
   // 0x1C.U -> 0x41.U, ...
   val keycode_to_ascii = Seq(
-    0x1c.U,
-    0x32.U,
-    0x21.U,
-    0x23.U,
-    0x24.U,
-    0x2b.U,
-    0x34.U,
-    0x33.U,
-    0x43.U,
-    0x3b.U,
-    0x42.U,
-    0x4b.U,
-    0x3a.U,
-    0x31.U,
-    0x44.U,
-    0x4d.U,
-    0x15.U,
-    0x2d.U,
-    0x1b.U,
-    0x2c.U,
-    0x3c.U,
-    0x2a.U,
-    0x1d.U,
-    0x22.U,
-    0x35.U,
-    0x1a.U,
-    0x45.U,
-    0x16.U,
-    0x1e.U,
-    0x26.U,
-    0x25.U,
-    0x2e.U,
-    0x36.U,
-    0x3d.U,
-    0x3e.U,
-    0x46.U
-  ).zip(((0x41 to 0x5a) ++ (0x30 to 0x39)).map(_.U))
+    0x1C.U, 0x32.U, 0x21.U, 0x23.U, 0x24.U, 0x2B.U,
+    0x34.U, 0x33.U, 0x43.U, 0x3B.U, 0x42.U, 0x4B.U,
+    0x3A.U, 0x31.U, 0x44.U, 0x4D.U, 0x15.U, 0x2D.U,
+    0x1B.U, 0x2C.U, 0x3C.U, 0x2A.U, 0x1D.U, 0x22.U,
+    0x35.U, 0x1A.U, 0x45.U, 0x16.U, 0x1E.U, 0x26.U,
+    0x25.U, 0x2E.U, 0x36.U, 0x3D.U, 0x3E.U, 0x46.U,
+  ).zip(((0x41 to 0x5A) ++ (0x30 to 0x39)).map(_.U))
 
   val keycode = RegInit(0.U(8.W))
-  val counter = Counter(0xff)
+  val counter = Counter(0xFF)
   val release_state = RegInit(Bool(), false.B)
   when(io.keycode.ready && io.keycode.valid) {
-    when(io.keycode.bits === 0xf0.U) {
+    when(io.keycode.bits === 0xF0.U) {
       release_state := true.B
     }.elsewhen(!release_state) {
       counter.inc()
       keycode := io.keycode.bits
-    }.otherwise {
+    }.otherwise{
       // Release code on io.keycode.bits
       release_state := false.B
     }
   }
 
-  val keycode_digits = VecInit(keycode(3, 0)) ++ VecInit(keycode(7, 4))
+  val keycode_digits = VecInit(keycode(3,0)) ++ VecInit(keycode(7,4))
   val ascii = MuxLookup(keycode, 0.U)(keycode_to_ascii)
 
   val seg_contoller = Module(new SegControllerGenerator(8, UInt(8.W)))
diff --git a/npc/core/src/main/scala/utils/SegControllerGenerator.scala b/npc/core/src/main/scala/utils/SegControllerGenerator.scala
index fdfcbc8..7f2cb68 100644
--- a/npc/core/src/main/scala/utils/SegControllerGenerator.scala
+++ b/npc/core/src/main/scala/utils/SegControllerGenerator.scala
@@ -9,32 +9,16 @@ class SegControllerGenerator[T <: Data](seg_count: Int, t: T) extends Module {
     val in_segs = Input(Vec(seg_count / ((t.getWidth + 3) / 4), t))
     val segs = Output(Vec(seg_count, UInt(8.W)))
   })
-  val digit_to_seg = ((0 until 16)
-    .map(_.U))
-    .zip(
-      Seq(
-        "b00000011".U,
-        "b10011111".U,
-        "b00100101".U,
-        "b00001101".U,
-        "b10011001".U,
-        "b01001001".U,
-        "b01000001".U,
-        "b00011111".U,
-        "b00000001".U,
-        "b00001001".U,
-        "b00010001".U,
-        "b11000001".U,
-        "b01100011".U,
-        "b10000101".U,
-        "b01100001".U,
-        "b01110001".U
-      )
-    )
+  val digit_to_seg = ((0 until 16).map(_.U)).zip(Seq(
+    "b00000011".U, "b10011111".U, "b00100101".U, "b00001101".U,
+    "b10011001".U, "b01001001".U, "b01000001".U, "b00011111".U,
+    "b00000001".U, "b00001001".U, "b00010001".U, "b11000001".U,
+    "b01100011".U, "b10000101".U, "b01100001".U, "b01110001".U,
+  ))
   val vec = io.in_segs.asTypeOf(Vec(seg_count, UInt(4.W)))
 
   val segs = VecInit(Seq.fill(seg_count)(0.U(8.W)))
-  segs := vec.map(MuxLookup(_, 0xff.U)(digit_to_seg))
+  segs := vec.map(MuxLookup(_, 0xFF.U)(digit_to_seg))
 
   io.segs := segs
 }
diff --git a/npc/core/src/test/scala/CSR.scala b/npc/core/src/test/scala/CSR.scala
deleted file mode 100644
index 35d41e3..0000000
--- a/npc/core/src/test/scala/CSR.scala
+++ /dev/null
@@ -1,59 +0,0 @@
-package flow.tests
-
-import chisel3._
-import chiseltest._
-import org.scalatest.freespec.AnyFreeSpec
-import chiseltest.simulator.WriteVcdAnnotation
-
-import flow.components.CSRCore
-import flow.tests.defaultParams
-
-class CSRSpec extends AnyFreeSpec with ChiselScalatestTester {
-  implicit val p: flow.Params = defaultParams()
-  "should compile" in {
-    test(new CSRCore) { c =>
-      c.clock.step(1)
-    }
-  }
-  "Write" - {
-    "delayed" in {
-      test(new CSRCore) { c =>
-        val tv = BigInt("deadbeef", 16)
-        c.in.csrAddr.poke(c.nameToAddr("mstatus"))
-        c.in.writeData.poke(tv)
-        c.control.writeEnable.poke(c.control.csrWrite.csrWriteEnabled)
-        c.clock.step(1)
-
-        c.control.readEnable.poke(c.control.csrRead.csrReadEnabled)
-        c.out.readData.expect(0)
-        c.out.readValid.expect(1)
-
-        c.clock.step(1)
-        c.out.readValid.expect(1)
-        c.out.readData.expect(tv)
-      }
-    }
-  }
-
-  "Read" - {
-    "controlled by readEnable" in {
-      test(new CSRCore) { c =>
-        val tv = BigInt("deadbeef", 16)
-        c.in.csrAddr.poke(c.nameToAddr("mstatus"))
-        c.in.writeData.poke(tv)
-        c.control.readEnable.poke(c.control.csrRead.csrReadEnabled)
-        c.control.writeEnable.poke(c.control.csrWrite.csrWriteEnabled)
-        c.clock.step(1)
-
-        c.control.readEnable.poke(c.control.csrRead.csrReadDisabled)
-        c.out.readData.expect(0)
-        c.out.readValid.expect(0)
-
-        c.clock.step(1)
-        c.out.readData.expect(0)
-        c.out.readValid.expect(0)
-      }
-    }
-  }
-
-}
diff --git a/npc/core/src/test/scala/params.scala b/npc/core/src/test/scala/params.scala
deleted file mode 100644
index 2bb752d..0000000
--- a/npc/core/src/test/scala/params.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-package flow.tests
-
-import chisel3._
-import flow.Params
-
-object defaultParams {
-  def apply(): Params = new Params(XLEN = 32.W)
-}