diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 9ce0e26..b7cec56 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -207,7 +207,7 @@ private:
             ${it}<%}%>
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ ${instr.length/8};
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();<%instr.behavior.eachLine{%>
         ${it}<%}%>
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 40e0ab8..5df25e2 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -619,9 +619,9 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
             }
             return std::make_pair(entry, true);
         }
-        throw std::runtime_error("memory load file is not a valid elf file");
+        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file",name));
     }
-    throw std::runtime_error("memory load file not found");
+    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
 }
 
 template<typename BASE, features_e FEAT>
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 24ce7f0..b107aac 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -588,9 +588,9 @@ template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load
             }
             return std::make_pair(entry, true);
         }
-        throw std::runtime_error("memory load file is not a valid elf file");
+        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file",name));
     }
-    throw std::runtime_error("memory load file not found");
+    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
 }
 
 template <typename BASE>
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 1d65c68..6ac7d9b 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -690,9 +690,9 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
             }
             return std::make_pair(entry, true);
         }
-        throw std::runtime_error("memory load file is not a valid elf file");
+        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file",name));
     }
-    throw std::runtime_error("memory load file not found");
+    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
 }
 
 template<typename BASE, features_e FEAT>
diff --git a/src/iss/arch/tgc_c.h b/src/iss/arch/tgc_c.h
index 4d47835..2b0c9bc 100644
--- a/src/iss/arch/tgc_c.h
+++ b/src/iss/arch/tgc_c.h
@@ -53,7 +53,7 @@ template <> struct traits<tgc_c> {
     static constexpr std::array<const char*, 36> reg_aliases{
         {"ZERO", "RA", "SP", "GP", "TP", "T0", "T1", "T2", "S0", "S1", "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9", "S10", "S11", "T3", "T4", "T5", "T6", "PC", "NEXT_PC", "PRIV", "DPC"}};
 
-    enum constants {MISA_VAL=0b01000000000000000001000100000100, MARCHID_VAL=0x80000003, XLEN=32, INSTR_ALIGNMENT=2, RFS=32, fence=0, fencei=1, fencevmal=2, fencevmau=3, CSR_SIZE=4096, MUL_LEN=64};
+    enum constants {MISA_VAL=0b01000000000000000001000100000100, MARCHID_VAL=0x80000003, PGMASK=0b111111111111, XLEN=32, INSTR_ALIGNMENT=2, RFS=32, fence=0, fencei=1, fencevmal=2, fencevmau=3, CSR_SIZE=4096, MUL_LEN=64};
 
     constexpr static unsigned FP_REGS_SIZE = 0;
 
diff --git a/src/vm/tcc/vm_tgc_c.cpp b/src/vm/tcc/vm_tgc_c.cpp
index f68372f..f47fb28 100644
--- a/src/vm/tcc/vm_tgc_c.cpp
+++ b/src/vm/tcc/vm_tgc_c.cpp
@@ -380,10 +380,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "lui"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -412,10 +412,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#08x}", fmt::arg("mnemonic", "auipc"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -444,10 +444,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#0x}", fmt::arg("mnemonic", "jal"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -462,7 +462,7 @@ private:
         		}
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int32_t)sext<21>(imm),32)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -484,10 +484,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm:#0x}", fmt::arg("mnemonic", "jalr"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -503,7 +503,7 @@ private:
         	}
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(new_pc,tu.constant(~ 0x1,8)),32);
         	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -525,10 +525,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "beq"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -541,7 +541,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -564,10 +564,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "bne"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -580,7 +580,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -603,10 +603,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "blt"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -619,7 +619,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -642,10 +642,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "bge"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -658,7 +658,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -681,10 +681,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "bltu"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -697,7 +697,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -720,10 +720,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rs2}, {imm:#0x}", fmt::arg("mnemonic", "bgeu"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -736,7 +736,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<13>(imm),16)),32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         	}
         	tu.close_scope();
         }
@@ -759,10 +759,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm}({rs1})", fmt::arg("mnemonic", "lb"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -794,10 +794,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm}({rs1})", fmt::arg("mnemonic", "lh"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -829,10 +829,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm}({rs1})", fmt::arg("mnemonic", "lw"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -864,10 +864,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm}({rs1})", fmt::arg("mnemonic", "lbu"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -899,10 +899,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm}({rs1})", fmt::arg("mnemonic", "lhu"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -934,10 +934,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs2}, {imm}({rs1})", fmt::arg("mnemonic", "sb"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -966,10 +966,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs2}, {imm}({rs1})", fmt::arg("mnemonic", "sh"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -998,10 +998,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs2}, {imm}({rs1})", fmt::arg("mnemonic", "sw"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("imm", imm), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1030,10 +1030,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "addi"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1063,10 +1063,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "slti"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1096,10 +1096,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "sltiu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1129,10 +1129,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "xori"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1162,10 +1162,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "ori"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1195,10 +1195,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {imm}", fmt::arg("mnemonic", "andi"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1228,10 +1228,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {shamt}", fmt::arg("mnemonic", "slli"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("shamt", shamt));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1261,10 +1261,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {shamt}", fmt::arg("mnemonic", "srli"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("shamt", shamt));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1294,10 +1294,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {shamt}", fmt::arg("mnemonic", "srai"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("shamt", shamt));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1327,10 +1327,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "add"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1360,10 +1360,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "sub"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1393,10 +1393,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "sll"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1426,10 +1426,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "slt"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1459,10 +1459,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "sltu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1492,10 +1492,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "xor"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1525,10 +1525,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "srl"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1558,10 +1558,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "sra"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1591,10 +1591,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "or"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1624,10 +1624,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "and"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1659,10 +1659,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {pred}, {succ} ({fm} , {rs1}, {rd})", fmt::arg("mnemonic", "fence"),
                 fmt::arg("pred", pred), fmt::arg("succ", succ), fmt::arg("fm", fm), fmt::arg("rs1", name(rs1)), fmt::arg("rd", name(rd)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.write_mem(traits::MEM, static_cast<uint32_t>(traits:: fence), tu.constant(pred<< 4|succ,8));
@@ -1679,10 +1679,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,38);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "ecall");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "ecall");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0,  11);
@@ -1699,10 +1699,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,39);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "ebreak");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "ebreak");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0,  3);
@@ -1719,10 +1719,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,40);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "mret");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "mret");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_leave_trap(tu, 3);
@@ -1739,10 +1739,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,41);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "wfi");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "wfi");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_wait(tu, 1);
@@ -1765,10 +1765,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {rs1}", fmt::arg("mnemonic", "csrrw"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -1776,7 +1776,7 @@ private:
         }
         else{
         	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
-        	if(rd!= 0){ auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	if(rd!= 0){ auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::MEM, csr, xrs1);
         	tu.store(rd + traits::X0,xrd);
         	}
@@ -1803,17 +1803,17 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {rs1}", fmt::arg("mnemonic", "csrrs"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0,  2);
         }
         else{
-        	auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
         	if(rs1!= 0) {
         	    tu.write_mem(traits::MEM, csr, tu.bitwise_or(xrd,xrs1));
@@ -1841,17 +1841,17 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {rs1}", fmt::arg("mnemonic", "csrrc"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0,  2);
         }
         else{
-        	auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
         	if(rs1!= 0) {
         	    tu.write_mem(traits::MEM, csr, tu.bitwise_and(xrd,tu.logical_neg(xrs1)));
@@ -1879,17 +1879,17 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {zimm:#0x}", fmt::arg("mnemonic", "csrrwi"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("zimm", zimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0,  2);
         }
         else{
-        	auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::MEM, csr, tu.constant((uint32_t)zimm,32));
         	if(rd!= 0) {
         	    tu.store(rd + traits::X0,xrd);
@@ -1914,17 +1914,17 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {zimm:#0x}", fmt::arg("mnemonic", "csrrsi"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("zimm", zimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0,  2);
         }
         else{
-        	auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	if(zimm!= 0) {
         	    tu.write_mem(traits::MEM, csr, tu.bitwise_or(xrd,tu.constant((uint32_t)zimm,32)));
         	}
@@ -1951,17 +1951,17 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {csr}, {zimm:#0x}", fmt::arg("mnemonic", "csrrci"),
                 fmt::arg("rd", name(rd)), fmt::arg("csr", csr), fmt::arg("zimm", zimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0,  2);
         }
         else{
-        	auto xrd = tu.assignment(tu.read_mem(traits::MEM, csr, 32),32);
+        	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	if(zimm!= 0) {
         	    tu.write_mem(traits::MEM, csr, tu.bitwise_and(xrd,tu.constant(~ ((uint32_t)zimm),32)));
         	}
@@ -1988,10 +1988,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {rd}, {imm}", fmt::arg("mnemonic", "fence_i"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.write_mem(traits::MEM, static_cast<uint32_t>(traits:: fencei), tu.constant(imm,16));
@@ -2014,10 +2014,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "mul"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2048,10 +2048,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "mulh"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2082,10 +2082,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "mulhsu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2116,10 +2116,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "mulhu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2150,10 +2150,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "div"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2193,10 +2193,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "divu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2232,10 +2232,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "rem"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2278,10 +2278,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs1}, {rs2}", fmt::arg("mnemonic", "remu"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs1", name(rs1)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2316,10 +2316,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "caddi4spn"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(imm) {
@@ -2347,10 +2347,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "clw"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         auto load_address = tu.assignment(tu.add(tu.load(rs1+ 8+ traits::X0, 0),tu.constant(uimm,8)),32);
@@ -2374,10 +2374,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "csw"),
                 fmt::arg("rs2", name(8+rs2)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         auto load_address = tu.assignment(tu.add(tu.load(rs1+ 8+ traits::X0, 0),tu.constant(uimm,8)),32);
@@ -2400,10 +2400,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "caddi"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2428,10 +2428,10 @@ private:
         uint8_t nzimm = ((bit_sub<2,5>(instr)) | (bit_sub<12,1>(instr) << 5));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "cnop");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "cnop");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         auto returnValue = std::make_tuple(CONT);
@@ -2451,16 +2451,16 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "cjal"),
                 fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(1 + traits::X0,tu.add(tu.ext(cur_pc_val,32,false),tu.constant( 2,32)));
         auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<12>(imm),16)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         auto returnValue = std::make_tuple(BRANCH);
         tu.close_scope();
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,62);
@@ -2479,10 +2479,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "cli"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2511,10 +2511,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "clui"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(imm== 0||rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2540,10 +2540,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "caddi16sp"),
                 fmt::arg("nzimm", nzimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(nzimm) {
@@ -2566,10 +2566,10 @@ private:
         uint8_t rd = ((bit_sub<7,5>(instr)));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "__reserved_clui");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "__reserved_clui");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0,  2);
@@ -2591,10 +2591,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "csrli"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rs1+ 8 + traits::X0,tu.lshr(tu.load(rs1+ 8+ traits::X0, 0),tu.constant(shamt,8)));
@@ -2616,10 +2616,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "csrai"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(shamt){ tu.store(rs1+ 8 + traits::X0,tu.lshr((tu.ext(tu.load(rs1+ 8+ traits::X0, 0),32,false)),tu.constant(shamt,8)));
@@ -2646,10 +2646,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "candi"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rs1+ 8 + traits::X0,tu.bitwise_and(tu.load(rs1+ 8+ traits::X0, 0),tu.constant((int8_t)sext<6>(imm),8)));
@@ -2671,10 +2671,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "csub"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rd+ 8 + traits::X0,tu.sub(tu.load(rd+ 8+ traits::X0, 0),tu.load(rs2+ 8+ traits::X0, 0)));
@@ -2696,10 +2696,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "cxor"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rd+ 8 + traits::X0,tu.bitwise_xor(tu.load(rd+ 8+ traits::X0, 0),tu.load(rs2+ 8+ traits::X0, 0)));
@@ -2721,10 +2721,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "cor"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rd+ 8 + traits::X0,tu.bitwise_or(tu.load(rd+ 8+ traits::X0, 0),tu.load(rs2+ 8+ traits::X0, 0)));
@@ -2746,10 +2746,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "cand"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.store(rd+ 8 + traits::X0,tu.bitwise_and(tu.load(rd+ 8+ traits::X0, 0),tu.load(rs2+ 8+ traits::X0, 0)));
@@ -2770,15 +2770,15 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "cj"),
                 fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<12>(imm),16)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         auto returnValue = std::make_tuple(BRANCH);
         tu.close_scope();
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,74);
@@ -2797,16 +2797,16 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "cbeqz"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,tu.load(rs1+ 8+ traits::X0, 0),tu.constant( 0,32)));
         auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<9>(imm),16)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         tu.close_scope();
@@ -2826,16 +2826,16 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "cbnez"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,tu.load(rs1+ 8+ traits::X0, 0),tu.constant( 0,32)));
         auto PC_val_v = tu.assignment("PC_val", tu.add(tu.ext(cur_pc_val,32,false),tu.constant((int16_t)sext<9>(imm),16)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         tu.close_scope();
@@ -2855,10 +2855,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "cslli"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("nzuimm", nzuimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2887,10 +2887,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "clwsp"),
                 fmt::arg("rd", name(rd)), fmt::arg("uimm", uimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rd== 0) {
@@ -2918,10 +2918,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "cmv"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -2949,16 +2949,16 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "cjr"),
                 fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)) {
             auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),tu.constant(~ 0x1,8)),32);
             tu.store(traits::NEXT_PC, PC_val_v);
-            tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+            tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }
         else{
         	this->gen_raise_trap(tu, 0, 2);
@@ -2976,10 +2976,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,81);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "__reserved_cmv");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "__reserved_cmv");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0, 2);
@@ -3001,10 +3001,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "cadd"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
@@ -3032,10 +3032,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "cjalr"),
                 fmt::arg("rs1", name(rs1)));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
@@ -3046,7 +3046,7 @@ private:
         	tu.store(1 + traits::X0,tu.add(tu.ext(cur_pc_val,32,false),tu.constant( 2,32)));
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(new_pc,tu.constant(~ 0x1,8)),32);
         	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(1U, 1));
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }
         auto returnValue = std::make_tuple(BRANCH);
         tu.close_scope();
@@ -3061,10 +3061,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,84);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "cebreak");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "cebreak");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0,  3);
@@ -3086,10 +3086,10 @@ private:
             auto mnemonic = fmt::format(
                 "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "cswsp"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("uimm", uimm));
-            this->core.disass_output(pc.val, mnemonic);
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)) {
@@ -3112,10 +3112,10 @@ private:
         vm_base<ARCH>::gen_sync(tu, PRE_SYNC,86);
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            this->core.disass_output(pc.val, "dii");
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "dii");
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
-        pc=pc+4;
+        pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_raise_trap(tu, 0,  2);