diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 9cdfbfe..e01d400 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -195,7 +195,7 @@ private:
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
         }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
-        gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 2c19cbe..79b937e 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -351,8 +351,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)((int32_t)imm),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)((int32_t)imm),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -387,8 +386,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)(PC+(int32_t)imm),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+(int32_t)imm),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -429,8 +427,7 @@ private:
         	}
         	else{
         		if(rd!=0) {
-        		    tu.store(rd + traits::X0,
-        		          tu.constant((uint32_t)(PC+4),32));
+        		    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+4),32));
         		}
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
@@ -473,7 +470,7 @@ private:
         	auto addr_mask = (uint32_t)- 2;
         	auto new_pc = tu.assignment(tu.ext((tu.bitwise_and(
         	   (tu.add(
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant((int16_t)sext<12>(imm),16))),
         	   tu.constant(addr_mask,32))),32,false),32);
         	tu.open_if(tu.urem(
@@ -483,8 +480,7 @@ private:
         	this->gen_raise_trap(tu, 0, 0);
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)(PC+4),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+4),32));
         	}
         	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         	tu.store(traits::NEXT_PC, PC_val_v);
@@ -525,8 +521,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -572,8 +568,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -619,8 +615,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -666,8 +662,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -713,8 +709,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -760,8 +756,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -806,12 +802,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 8),8,true),8);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -847,12 +842,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 16),16,true),16);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -888,12 +882,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 32),32,true),32);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -929,12 +922,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.read_mem(traits::MEM, load_address, 8),8);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -970,12 +962,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.read_mem(traits::MEM, load_address, 16),16);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1011,9 +1002,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),8,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),8,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1048,9 +1039,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),16,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),16,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1085,9 +1076,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),32,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1122,10 +1113,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((int16_t)sext<12>(imm),16))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((int16_t)sext<12>(imm),16))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1161,10 +1151,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_SLT,
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.constant((int16_t)sext<12>(imm),16))), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_SLT,
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.constant((int16_t)sext<12>(imm),16))), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1200,10 +1189,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_ULT,
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32))), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_ULT,
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32))), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1239,10 +1227,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_xor(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_xor(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1278,10 +1265,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_or(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_or(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1317,10 +1303,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_and(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_and(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1356,10 +1341,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(shamt,8)));
+        	    tu.store(rd + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(shamt,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1395,10 +1379,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.lshr(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(shamt,8)));
+        	    tu.store(rd + traits::X0, tu.lshr(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(shamt,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1434,10 +1417,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.constant(shamt,8))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.constant(shamt,8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1473,10 +1455,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1512,10 +1493,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.sub(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.sub(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1551,12 +1531,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
+        	    tu.store(rd + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1592,10 +1571,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_SLT,
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.ext(tu.load(rs2+ traits::X0, 0),32,true)), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_SLT,
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.ext(tu.load(rs2 + traits::X0, 0),32,true)), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1631,10 +1609,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_ULT,
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_ULT,
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1670,10 +1647,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_xor(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_xor(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1709,12 +1685,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.lshr(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
+        	    tu.store(rd + traits::X0, tu.lshr(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1750,12 +1725,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64))))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64))))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1791,10 +1765,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_or(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_or(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1830,10 +1803,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_and(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_and(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2002,11 +1974,10 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rd!=0){ auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::CSR, csr, xrs1);
-        	tu.store(rd + traits::X0,
-        	      xrd);
+        	tu.store(rd + traits::X0, xrd);
         	}
         	else{
         		tu.write_mem(traits::CSR, csr, xrs1);
@@ -2045,15 +2016,14 @@ private:
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rs1!=0) {
         	    tu.write_mem(traits::CSR, csr, tu.bitwise_or(
         	       xrd,
         	       xrs1));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2089,15 +2059,14 @@ private:
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rs1!=0) {
         	    tu.write_mem(traits::CSR, csr, tu.bitwise_and(
         	       xrd,
         	       tu.logical_neg(xrs1)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2135,8 +2104,7 @@ private:
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::CSR, csr, tu.constant((uint32_t)zimm,32));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2178,8 +2146,7 @@ private:
         	       tu.constant((uint32_t)zimm,32)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2221,8 +2188,7 @@ private:
         	       tu.constant(~ ((uint32_t)zimm),32)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2287,11 +2253,10 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2327,13 +2292,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2369,13 +2333,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.load(rs2+ traits::X0, 0)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.load(rs2 + traits::X0, 0)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2411,13 +2374,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)),64);
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.lshr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.lshr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2452,30 +2414,27 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto dividend = tu.assignment(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),32);
-        	auto divisor = tu.assignment(tu.ext(tu.load(rs2+ traits::X0, 0),32,true),32);
+        	auto dividend = tu.assignment(tu.ext(tu.load(rs1 + traits::X0, 0),32,true),32);
+        	auto divisor = tu.assignment(tu.ext(tu.load(rs2 + traits::X0, 0),32,true),32);
         	if(rd!=0){ tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   divisor,
         	   tu.constant(0,8)));
         	auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      divisor,
         	      tu.constant(- 1,8))));
-        	tu.store(rd + traits::X0,
-        	      tu.constant(MMIN,32));
+        	tu.store(rd + traits::X0, tu.constant(MMIN,32));
         	tu.open_else();
-        	tu.store(rd + traits::X0,
-        	      tu.ext((tu.sdiv(
-        	         dividend,
-        	         divisor)),32,false));
+        	tu.store(rd + traits::X0, tu.ext((tu.sdiv(
+        	   dividend,
+        	   divisor)),32,false));
         	tu.close_scope();
         	tu.open_else();
-        	tu.store(rd + traits::X0,
-        	      tu.constant((uint32_t)- 1,32));
+        	tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
         	tu.close_scope();
         	}
         }
@@ -2512,18 +2471,16 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.udiv(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.udiv(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)- 1,32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
         	}
         	tu.close_scope();
         }
@@ -2560,32 +2517,29 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.ext(tu.load(rs2+ traits::X0, 0),32,true),
+        	      tu.ext(tu.load(rs2 + traits::X0, 0),32,true),
         	      tu.constant(- 1,8))));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant(0,8));
+        	    tu.store(rd + traits::X0, tu.constant(0,8));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.srem(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.ext(tu.load(rs2+ traits::X0, 0),32,true))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.srem(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.ext(tu.load(rs2 + traits::X0, 0),32,true))),32,false));
         	}
         	tu.close_scope();
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs1+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
         	tu.close_scope();
         }
@@ -2622,18 +2576,16 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.urem(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.urem(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs1+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
         	tu.close_scope();
         }
@@ -2665,10 +2617,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         if(imm) {
-            tu.store(rd+8 + traits::X0,
-                  tu.ext((tu.add(
-                     tu.load(2+ traits::X0, 0),
-                     tu.constant(imm,16))),32,false));
+            tu.store(rd+8 + traits::X0, tu.ext((tu.add(
+               tu.load(2 + traits::X0, 0),
+               tu.constant(imm,16))),32,false));
         }
         else{
         	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2702,10 +2653,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
-        tu.store(rd+8 + traits::X0,
-              tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
+        tu.store(rd+8 + traits::X0, tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -2735,9 +2685,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
-        tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+8+ traits::X0, 0),32,false));
+        tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+8 + traits::X0, 0),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -2770,10 +2720,9 @@ private:
         }
         else{
         	if(rs1!=0) {
-        	    tu.store(rs1 + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((int8_t)sext<6>(imm),8))),32,false));
+        	    tu.store(rs1 + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((int8_t)sext<6>(imm),8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2828,8 +2777,7 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
-        tu.store(1 + traits::X0,
-              tu.constant((uint32_t)(PC+2),32));
+        tu.store(1 + traits::X0, tu.constant((uint32_t)(PC+2),32));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
@@ -2865,8 +2813,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)((int8_t)sext<6>(imm)),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)((int8_t)sext<6>(imm)),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2900,8 +2847,7 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0) {
-            tu.store(rd + traits::X0,
-                  tu.constant((uint32_t)((int32_t)sext<18>(imm)),32));
+            tu.store(rd + traits::X0, tu.constant((uint32_t)((int32_t)sext<18>(imm)),32));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -2930,10 +2876,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         if(nzimm) {
-            tu.store(2 + traits::X0,
-                  tu.ext((tu.add(
-                     tu.load(2+ traits::X0, 0),
-                     tu.constant((int16_t)sext<10>(nzimm),16))),32,false));
+            tu.store(2 + traits::X0, tu.ext((tu.add(
+               tu.load(2 + traits::X0, 0),
+               tu.constant((int16_t)sext<10>(nzimm),16))),32,false));
         }
         else{
         	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2991,10 +2936,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rs1+8 + traits::X0,
-              tu.lshr(
-                 tu.load(rs1+8+ traits::X0, 0),
-                 tu.constant(shamt,8)));
+        tu.store(rs1+8 + traits::X0, tu.lshr(
+           tu.load(rs1+8 + traits::X0, 0),
+           tu.constant(shamt,8)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3022,16 +2966,14 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        if(shamt){ tu.store(rs1+8 + traits::X0,
-              tu.ext((tu.ashr(
-                 (tu.ext(tu.load(rs1+8+ traits::X0, 0),32,true)),
-                 tu.constant(shamt,8))),32,false));
+        if(shamt){ tu.store(rs1+8 + traits::X0, tu.ext((tu.ashr(
+           (tu.ext(tu.load(rs1+8 + traits::X0, 0),32,true)),
+           tu.constant(shamt,8))),32,false));
         }
         else{
-        	if(static_cast<uint32_t>(traits:: XLEN)==128){ tu.store(rs1+8 + traits::X0,
-        	      tu.ext((tu.ashr(
-        	         (tu.ext(tu.load(rs1+8+ traits::X0, 0),32,true)),
-        	         tu.constant(64,8))),32,false));
+        	if(static_cast<uint32_t>(traits:: XLEN)==128){ tu.store(rs1+8 + traits::X0, tu.ext((tu.ashr(
+        	   (tu.ext(tu.load(rs1+8 + traits::X0, 0),32,true)),
+        	   tu.constant(64,8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3061,10 +3003,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rs1+8 + traits::X0,
-              tu.ext((tu.bitwise_and(
-                 tu.load(rs1+8+ traits::X0, 0),
-                 tu.constant((int8_t)sext<6>(imm),8))),32,false));
+        tu.store(rs1+8 + traits::X0, tu.ext((tu.bitwise_and(
+           tu.load(rs1+8 + traits::X0, 0),
+           tu.constant((int8_t)sext<6>(imm),8))),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3092,10 +3033,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.ext((tu.sub(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0))),32,false));
+        tu.store(rd+8 + traits::X0, tu.ext((tu.sub(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0))),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3123,10 +3063,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_xor(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_xor(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3154,10 +3093,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_or(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_or(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3185,10 +3123,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_and(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_and(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3248,7 +3185,7 @@ private:
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
@@ -3283,7 +3220,7 @@ private:
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
@@ -3321,10 +3258,9 @@ private:
         }
         else{
         	if(rs1!=0) {
-        	    tu.store(rs1 + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(nzuimm,8)));
+        	    tu.store(rs1 + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(nzuimm,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3359,10 +3295,9 @@ private:
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
-        	   tu.load(2+ traits::X0, 0),
+        	   tu.load(2 + traits::X0, 0),
         	   tu.constant(uimm,8))),32,false),32);
-        	tu.store(rd + traits::X0,
-        	      tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
+        	tu.store(rd + traits::X0, tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -3396,8 +3331,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs2+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs2 + traits::X0, 0));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3429,7 +3363,7 @@ private:
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = (uint32_t)- 2;
         auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
-           tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
+           tu.load(rs1%static_cast<uint32_t>(traits:: RFS) + traits::X0, 0),
            tu.constant(addr_mask,32)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
@@ -3494,10 +3428,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rd+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rd + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3532,9 +3465,8 @@ private:
         }
         else{
         	auto addr_mask = (uint32_t)- 2;
-        	auto new_pc = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
-        	tu.store(1 + traits::X0,
-        	      tu.constant((uint32_t)(PC+2),32));
+        	auto new_pc = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
+        	tu.store(1 + traits::X0, tu.constant((uint32_t)(PC+2),32));
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
         	   new_pc,
         	   tu.constant(addr_mask,32)),32);
@@ -3598,9 +3530,9 @@ private:
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
-        	   tu.load(2+ traits::X0, 0),
+        	   tu.load(2 + traits::X0, 0),
         	   tu.constant(uimm,8))),32,false),32);
-        	tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+ traits::X0, 0),32,false));
+        	tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2 + traits::X0, 0),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -3645,7 +3577,7 @@ private:
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
         }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
-        gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);