From 913ee989dd50bf061fe9bb1904cd90e1f5759608 Mon Sep 17 00:00:00 2001
From: Andrew Waterman <waterman@s141.Millennium.Berkeley.EDU>
Date: Sun, 24 Apr 2011 21:22:40 -0700
Subject: [PATCH] [xcc,sim,opcodes] added c.addiw

---
 riscv/execute.h       | 4889 ++++++++---------------------------------
 riscv/insns/c_addiw.h |    3 +
 2 files changed, 941 insertions(+), 3951 deletions(-)
 create mode 100644 riscv/insns/c_addiw.h

diff --git a/riscv/execute.h b/riscv/execute.h
index c4ff806..059370a 100644
--- a/riscv/execute.h
+++ b/riscv/execute.h
@@ -13,10 +13,6 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0x2:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
         if((insn.bits & 0x801f) == 0x2)
         {
           #include "insns/c_move.h"
@@ -28,156 +24,46 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
+    break;
+  }
+  case 0x3:
+  {
+        if((insn.bits & 0x3ff) == 0x3)
         {
-          #include "insns/c_j.h"
+          #include "insns/lb.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff) == 0x83)
         {
-          #include "insns/c_move.h"
+          #include "insns/lh.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x3ff) == 0x103)
         {
-          #include "insns/c_j.h"
+          #include "insns/lw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff) == 0x183)
         {
-          #include "insns/c_move.h"
+          #include "insns/ld.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x3ff) == 0x303)
         {
-          #include "insns/c_j.h"
+          #include "insns/lwu.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff) == 0x203)
         {
-          #include "insns/c_move.h"
+          #include "insns/lbu.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x3ff) == 0x283)
         {
-          #include "insns/c_j.h"
+          #include "insns/lhu.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x3:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/lb.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/lh.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/lw.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/ld.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/lbu.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/lhu.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/lwu.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0x4:
@@ -197,23 +83,17 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0x7:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x2:
-      {
-        #include "insns/flw.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/fld.h"
-        break;
-      }
-      default:
-      {
+        if((insn.bits & 0x3ff) == 0x107)
+        {
+          #include "insns/flw.h"
+          break;
+        }
+        if((insn.bits & 0x3ff) == 0x187)
+        {
+          #include "insns/fld.h"
+          break;
+        }
         throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0x8:
@@ -233,121 +113,114 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0xb:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1ffff) == 0x280b)
+        if((insn.bits & 0x1ffff) == 0x230b)
         {
-          #include "insns/sbseg_v.h"
+          #include "insns/lwuseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x100b)
+        if((insn.bits & 0x3fffff) == 0x10b)
         {
-          #include "insns/lbst_v.h"
+          #include "insns/lw_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x180b)
+        if((insn.bits & 0x3fffff) == 0x30b)
         {
-          #include "insns/sbst_v.h"
+          #include "insns/lwu_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0xb)
+        if((insn.bits & 0x1ffff) == 0x1810b)
         {
-          #include "insns/lb_v.h"
+          #include "insns/fmov_su.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x200b)
+        if((insn.bits & 0x1ffff) == 0x290b)
         {
-          #include "insns/lbseg_v.h"
+          #include "insns/swseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x1000b)
+        if((insn.bits & 0x1ffff) == 0x280b)
         {
-          #include "insns/mov_vv.h"
+          #include "insns/sbseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x1800b)
+        if((insn.bits & 0x3fffff) == 0x20b)
         {
-          #include "insns/fmov_vv.h"
+          #include "insns/lbu_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x80b)
+        if((insn.bits & 0x1ffff) == 0x100b)
         {
-          #include "insns/sb_v.h"
+          #include "insns/lbst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1ffff) == 0x208b)
+        if((insn.bits & 0x1ffff) == 0x218b)
         {
-          #include "insns/lhseg_v.h"
+          #include "insns/ldseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x108b)
+        if((insn.bits & 0x1ffff) == 0x180b)
         {
-          #include "insns/lhst_v.h"
+          #include "insns/sbst_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x1008b)
+        if((insn.bits & 0x3fffff) == 0x58b)
         {
-          #include "insns/mov_sv.h"
+          #include "insns/fld_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x1808b)
+        if((insn.bits & 0x1ffff) == 0x208b)
         {
-          #include "insns/fmov_sv.h"
+          #include "insns/lhseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x8b)
+        if((insn.bits & 0x1ffff) == 0x220b)
         {
-          #include "insns/lh_v.h"
+          #include "insns/lbuseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x88b)
+        if((insn.bits & 0x1ffff) == 0x108b)
         {
-          #include "insns/sh_v.h"
+          #include "insns/lhst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x288b)
+        if((insn.bits & 0x1ffff) == 0x128b)
         {
-          #include "insns/shseg_v.h"
+          #include "insns/lhust_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x188b)
+        if((insn.bits & 0x3fffff) == 0x1008b)
         {
-          #include "insns/shst_v.h"
+          #include "insns/mov_sv.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x3fffff) == 0x10b)
+        if((insn.bits & 0x1ffff) == 0x1010b)
         {
-          #include "insns/lw_v.h"
+          #include "insns/mov_su.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1810b)
+        if((insn.bits & 0x3fffff) == 0x18b)
         {
-          #include "insns/fmov_su.h"
+          #include "insns/ld_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x290b)
+        if((insn.bits & 0x1ffff) == 0x1d0b)
         {
-          #include "insns/swseg_v.h"
+          #include "insns/fswst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1010b)
+        if((insn.bits & 0x3fffff) == 0xd8b)
         {
-          #include "insns/mov_su.h"
+          #include "insns/fsd_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1d0b)
+        if((insn.bits & 0x3fffff) == 0x1808b)
         {
-          #include "insns/fswst_v.h"
+          #include "insns/fmov_sv.h"
+          break;
+        }
+        if((insn.bits & 0x1ffff) == 0x2d8b)
+        {
+          #include "insns/fsdseg_v.h"
           break;
         }
         if((insn.bits & 0x1ffff) == 0x190b)
@@ -355,184 +228,157 @@ switch((insn.bits >> 0x0) & 0x7f)
           #include "insns/swst_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0xd0b)
+        if((insn.bits & 0x1ffff) == 0x1d8b)
         {
-          #include "insns/fsw_v.h"
+          #include "insns/fsdst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x250b)
+        if((insn.bits & 0x3fffff) == 0xb)
         {
-          #include "insns/flwseg_v.h"
+          #include "insns/lb_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x50b)
+        if((insn.bits & 0x1ffff) == 0x118b)
         {
-          #include "insns/flw_v.h"
+          #include "insns/ldst_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x90b)
+        if((insn.bits & 0x1ffff) == 0x258b)
         {
-          #include "insns/sw_v.h"
+          #include "insns/fldseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x150b)
+        if((insn.bits & 0x3fffff) == 0x8b)
         {
-          #include "insns/flwst_v.h"
+          #include "insns/lh_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x210b)
+        if((insn.bits & 0x3fffff) == 0x28b)
         {
-          #include "insns/lwseg_v.h"
+          #include "insns/lhu_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x2d0b)
+        if((insn.bits & 0x1ffff) == 0x1018b)
         {
-          #include "insns/fswseg_v.h"
+          #include "insns/mov_us.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x110b)
+        if((insn.bits & 0x3fffff) == 0xd0b)
         {
-          #include "insns/lwst_v.h"
+          #include "insns/fsw_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1ffff) == 0x218b)
+        if((insn.bits & 0x1ffff) == 0x158b)
         {
-          #include "insns/ldseg_v.h"
+          #include "insns/fldst_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x58b)
+        if((insn.bits & 0x1ffff) == 0x250b)
         {
-          #include "insns/fld_v.h"
+          #include "insns/flwseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x18b)
+        if((insn.bits & 0x1ffff) == 0x200b)
         {
-          #include "insns/ld_v.h"
+          #include "insns/lbseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0xd8b)
+        if((insn.bits & 0x3fffff) == 0x50b)
         {
-          #include "insns/fsd_v.h"
+          #include "insns/flw_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x2d8b)
+        if((insn.bits & 0x3fffff) == 0x90b)
         {
-          #include "insns/fsdseg_v.h"
+          #include "insns/sw_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1d8b)
+        if((insn.bits & 0x1ffff) == 0x298b)
         {
-          #include "insns/fsdst_v.h"
+          #include "insns/sdseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x118b)
+        if((insn.bits & 0x1ffff) == 0x130b)
         {
-          #include "insns/ldst_v.h"
+          #include "insns/lwust_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x258b)
+        if((insn.bits & 0x1ffff) == 0x150b)
         {
-          #include "insns/fldseg_v.h"
+          #include "insns/flwst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1018b)
+        if((insn.bits & 0x3fffff) == 0x88b)
         {
-          #include "insns/mov_us.h"
+          #include "insns/sh_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x158b)
+        if((insn.bits & 0x1ffff) == 0x210b)
         {
-          #include "insns/fldst_v.h"
+          #include "insns/lwseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x298b)
+        if((insn.bits & 0x1ffff) == 0x2d0b)
         {
-          #include "insns/sdseg_v.h"
+          #include "insns/fswseg_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1818b)
+        if((insn.bits & 0x1ffff) == 0x288b)
         {
-          #include "insns/fmov_us.h"
+          #include "insns/shseg_v.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x98b)
+        if((insn.bits & 0x1ffff) == 0x1818b)
         {
-          #include "insns/sd_v.h"
+          #include "insns/fmov_us.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x198b)
+        if((insn.bits & 0x1ffff) == 0x228b)
         {
-          #include "insns/sdst_v.h"
+          #include "insns/lhuseg_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x3fffff) == 0x20b)
+        if((insn.bits & 0x1ffff) == 0x120b)
         {
-          #include "insns/lbu_v.h"
+          #include "insns/lbust_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x220b)
-        {
-          #include "insns/lbuseg_v.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x120b)
+        if((insn.bits & 0x3fffff) == 0x98b)
         {
-          #include "insns/lbust_v.h"
+          #include "insns/sd_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1ffff) == 0x128b)
+        if((insn.bits & 0x3fffff) == 0x1000b)
         {
-          #include "insns/lhust_v.h"
+          #include "insns/mov_vv.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x28b)
+        if((insn.bits & 0x1ffff) == 0x110b)
         {
-          #include "insns/lhu_v.h"
+          #include "insns/lwst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x228b)
+        if((insn.bits & 0x1ffff) == 0x198b)
         {
-          #include "insns/lhuseg_v.h"
+          #include "insns/sdst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1ffff) == 0x230b)
+        if((insn.bits & 0x3fffff) == 0x1800b)
         {
-          #include "insns/lwuseg_v.h"
+          #include "insns/fmov_vv.h"
           break;
         }
-        if((insn.bits & 0x3fffff) == 0x30b)
+        if((insn.bits & 0x1ffff) == 0x188b)
         {
-          #include "insns/lwu_v.h"
+          #include "insns/shst_v.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x130b)
+        if((insn.bits & 0x3fffff) == 0x80b)
         {
-          #include "insns/lwust_v.h"
+          #include "insns/sb_v.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0xc:
@@ -547,116 +393,82 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0xf:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0xfff) == 0x80f)
+        if((insn.bits & 0xfff) == 0x20f)
         {
-          #include "insns/sbsegst_v.h"
+          #include "insns/lbusegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0xf)
+        if((insn.bits & 0xfff) == 0x18f)
         {
-          #include "insns/lbsegst_v.h"
+          #include "insns/ldsegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0xfff) == 0x88f)
+        if((insn.bits & 0xfff) == 0x98f)
         {
-          #include "insns/shsegst_v.h"
+          #include "insns/sdsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x8f)
+        if((insn.bits & 0xfff) == 0x30f)
         {
-          #include "insns/lhsegst_v.h"
+          #include "insns/lwusegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0xfff) == 0xd0f)
+        if((insn.bits & 0xfff) == 0x80f)
         {
-          #include "insns/fswsegst_v.h"
+          #include "insns/sbsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x50f)
+        if((insn.bits & 0xfff) == 0x58f)
         {
-          #include "insns/flwsegst_v.h"
+          #include "insns/fldsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x10f)
+        if((insn.bits & 0xfff) == 0x28f)
         {
-          #include "insns/lwsegst_v.h"
+          #include "insns/lhusegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x90f)
+        if((insn.bits & 0xfff) == 0xf)
         {
-          #include "insns/swsegst_v.h"
+          #include "insns/lbsegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0xfff) == 0x18f)
+        if((insn.bits & 0xfff) == 0xd8f)
         {
-          #include "insns/ldsegst_v.h"
+          #include "insns/fsdsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x98f)
+        if((insn.bits & 0xfff) == 0xd0f)
         {
-          #include "insns/sdsegst_v.h"
+          #include "insns/fswsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0x58f)
+        if((insn.bits & 0xfff) == 0x88f)
         {
-          #include "insns/fldsegst_v.h"
+          #include "insns/shsegst_v.h"
           break;
         }
-        if((insn.bits & 0xfff) == 0xd8f)
+        if((insn.bits & 0xfff) == 0x50f)
         {
-          #include "insns/fsdsegst_v.h"
+          #include "insns/flwsegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0xfff) == 0x20f)
+        if((insn.bits & 0xfff) == 0x10f)
         {
-          #include "insns/lbusegst_v.h"
+          #include "insns/lwsegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0xfff) == 0x28f)
+        if((insn.bits & 0xfff) == 0x90f)
         {
-          #include "insns/lhusegst_v.h"
+          #include "insns/swsegst_v.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0xfff) == 0x30f)
+        if((insn.bits & 0xfff) == 0x8f)
         {
-          #include "insns/lwusegst_v.h"
+          #include "insns/lhsegst_v.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0x10:
@@ -671,52 +483,6 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0x12:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
         if((insn.bits & 0x801f) == 0x12)
         {
           #include "insns/c_lw0.h"
@@ -728,132 +494,56 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+    break;
+  }
+  case 0x13:
+  {
+        if((insn.bits & 0x3ff) == 0x193)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/sltiu.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3f03ff) == 0x293)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/srli.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x3ff) == 0x13)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/addi.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3f03ff) == 0x10293)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/srai.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x3ff) == 0x313)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/ori.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3ff) == 0x213)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/xori.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x3ff) == 0x393)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/andi.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3ff) == 0x113)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/slti.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x13:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/addi.h"
-        break;
-      }
-      case 0x1:
-      {
         if((insn.bits & 0x3f03ff) == 0x93)
         {
           #include "insns/slli.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        #include "insns/slti.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/sltiu.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/xori.h"
-        break;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x3f03ff) == 0x293)
-        {
-          #include "insns/srli.h"
-          break;
-        }
-        if((insn.bits & 0x3f03ff) == 0x10293)
-        {
-          #include "insns/srai.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        #include "insns/ori.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/andi.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0x14:
@@ -878,10 +568,6 @@ switch((insn.bits >> 0x0) & 0x7f)
   }
   case 0x19:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
         if((insn.bits & 0x1c1f) == 0x19)
         {
           #include "insns/c_slli.h"
@@ -918,614 +604,600 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
+    break;
+  }
+  case 0x1a:
+  {
+        if((insn.bits & 0x801f) == 0x1a)
         {
-          #include "insns/c_srli.h"
+          #include "insns/c_add.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x801f) == 0x801a)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/c_sub.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x1b:
+  {
+        if((insn.bits & 0x3f83ff) == 0x9b)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/slliw.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x3f83ff) == 0x29b)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/srliw.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x3ff) == 0x1b)
         {
-          #include "insns/c_srai.h"
+          #include "insns/addiw.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x3f83ff) == 0x1029b)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/sraiw.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+    break;
+  }
+  case 0x1c:
+  {
+        if((insn.bits & 0x31f) == 0x1c)
         {
-          #include "insns/c_slli.h"
+          #include "insns/c_add3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x31f) == 0x21c)
         {
-          #include "insns/c_srli.h"
+          #include "insns/c_or3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x31f) == 0x31c)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/c_and3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x31f) == 0x11c)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/c_sub3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x1d:
+  {
+    #include "insns/c_addiw.h"
+    break;
+  }
+  case 0x20:
+  {
+    #include "insns/c_li.h"
+    break;
+  }
+  case 0x21:
+  {
+    #include "insns/c_addi.h"
+    break;
+  }
+  case 0x22:
+  {
+        if((insn.bits & 0x801f) == 0x2)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/c_move.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x801f) == 0x8002)
         {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
+          #include "insns/c_j.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+    break;
+  }
+  case 0x23:
+  {
+        if((insn.bits & 0x3ff) == 0x123)
         {
-          #include "insns/c_slli.h"
+          #include "insns/sw.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x3ff) == 0xa3)
         {
-          #include "insns/c_srli.h"
+          #include "insns/sh.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x3ff) == 0x23)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/sb.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x3ff) == 0x1a3)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/sd.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x24:
+  {
+    #include "insns/c_ldsp.h"
+    break;
+  }
+  case 0x25:
+  {
+    #include "insns/c_lwsp.h"
+    break;
+  }
+  case 0x26:
+  {
+    #include "insns/c_sdsp.h"
+    break;
+  }
+  case 0x27:
+  {
+        if((insn.bits & 0x3ff) == 0x1a7)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/fsd.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x3ff) == 0x127)
         {
-          #include "insns/c_srai.h"
+          #include "insns/fsw.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x28:
+  {
+    #include "insns/c_swsp.h"
+    break;
+  }
+  case 0x29:
+  {
+    #include "insns/c_ld.h"
+    break;
+  }
+  case 0x2a:
+  {
+    #include "insns/c_lw.h"
+    break;
+  }
+  case 0x2b:
+  {
+        if((insn.bits & 0x1ffff) == 0x19ab)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/amominu_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x1ffff) == 0x192b)
         {
-          #include "insns/c_slli.h"
+          #include "insns/amominu_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x1ffff) == 0x9ab)
         {
-          #include "insns/c_srli.h"
+          #include "insns/amoand_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x1ffff) == 0x92b)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/amoand_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x1ffff) == 0x1dab)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/amomaxu_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x1ffff) == 0x1d2b)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/amomaxu_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x1ffff) == 0x1ab)
         {
-          #include "insns/c_srai.h"
+          #include "insns/amoadd_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x1ffff) == 0x152b)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/amomax_w.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x1ffff) == 0x12b)
         {
-          #include "insns/c_slli.h"
+          #include "insns/amoadd_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x1ffff) == 0x15ab)
         {
-          #include "insns/c_srli.h"
+          #include "insns/amomax_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x1ffff) == 0xdab)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/amoor_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x1ffff) == 0xd2b)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/amoor_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x1ffff) == 0x112b)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/amomin_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x1ffff) == 0x5ab)
         {
-          #include "insns/c_srai.h"
+          #include "insns/amoswap_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x1ffff) == 0x11ab)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/amomin_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x1ffff) == 0x52b)
         {
-          #include "insns/c_slli.h"
+          #include "insns/amoswap_w.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x2c:
+  {
+    #include "insns/c_sd.h"
+    break;
+  }
+  case 0x2d:
+  {
+    #include "insns/c_sw.h"
+    break;
+  }
+  case 0x2f:
+  {
+        if((insn.bits & 0x3ff) == 0x32f)
         {
-          #include "insns/c_srli.h"
+          #include "insns/fence_l_cv.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x3ff) == 0x2af)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/fence_g_v.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x3ff) == 0x12f)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/fence.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x3ff) == 0xaf)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/fence_i.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x3ff) == 0x3af)
         {
-          #include "insns/c_srai.h"
+          #include "insns/fence_g_cv.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x3ff) == 0x22f)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/fence_l_v.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+    break;
+  }
+  case 0x30:
+  {
+    #include "insns/c_beq.h"
+    break;
+  }
+  case 0x31:
+  {
+    #include "insns/c_bne.h"
+    break;
+  }
+  case 0x32:
+  {
+        if((insn.bits & 0x801f) == 0x12)
         {
-          #include "insns/c_slli.h"
+          #include "insns/c_lw0.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x801f) == 0x8012)
         {
-          #include "insns/c_srli.h"
+          #include "insns/c_ld0.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x33:
+  {
+        if((insn.bits & 0x1ffff) == 0x33)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/add.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x1ffff) == 0x433)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/mul.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x1ffff) == 0x633)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/div.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x1ffff) == 0xb3)
         {
-          #include "insns/c_srai.h"
+          #include "insns/sll.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x1ffff) == 0x233)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/xor.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x1a:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x10033)
         {
-          #include "insns/c_add.h"
+          #include "insns/sub.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x733)
         {
-          #include "insns/c_sub.h"
+          #include "insns/rem.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x4b3)
         {
-          #include "insns/c_add.h"
+          #include "insns/mulh.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x102b3)
         {
-          #include "insns/c_sub.h"
+          #include "insns/sra.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x2b3)
         {
-          #include "insns/c_add.h"
+          #include "insns/srl.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x333)
         {
-          #include "insns/c_sub.h"
+          #include "insns/or.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x533)
         {
-          #include "insns/c_add.h"
+          #include "insns/mulhsu.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x133)
         {
-          #include "insns/c_sub.h"
+          #include "insns/slt.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x7b3)
         {
-          #include "insns/c_add.h"
+          #include "insns/remu.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x1b3)
         {
-          #include "insns/c_sub.h"
+          #include "insns/sltu.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1ffff) == 0x3b3)
         {
-          #include "insns/c_add.h"
+          #include "insns/and.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1ffff) == 0x5b3)
         {
-          #include "insns/c_sub.h"
+          #include "insns/mulhu.h"
+          break;
+        }
+        if((insn.bits & 0x1ffff) == 0x6b3)
+        {
+          #include "insns/divu.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+    break;
+  }
+  case 0x34:
+  {
+    #include "insns/c_flw.h"
+    break;
+  }
+  case 0x35:
+  {
+    #include "insns/c_fld.h"
+    break;
+  }
+  case 0x36:
+  {
+    #include "insns/c_fsw.h"
+    break;
+  }
+  case 0x37:
+  {
+    #include "insns/lui.h"
+    break;
+  }
+  case 0x38:
+  {
+    #include "insns/c_fsd.h"
+    break;
+  }
+  case 0x39:
+  {
+        if((insn.bits & 0x1c1f) == 0x19)
         {
-          #include "insns/c_add.h"
+          #include "insns/c_slli.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1c1f) == 0x819)
         {
-          #include "insns/c_sub.h"
+          #include "insns/c_srli.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x1c1f) == 0x1419)
         {
-          #include "insns/c_add.h"
+          #include "insns/c_srai32.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0x1c1f) == 0xc19)
         {
-          #include "insns/c_sub.h"
+          #include "insns/c_srli32.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x1b:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/addiw.h"
-        break;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x3f83ff) == 0x9b)
+        if((insn.bits & 0x1c1f) == 0x1819)
         {
-          #include "insns/slliw.h"
+          #include "insns/c_slliw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x3f83ff) == 0x29b)
+        if((insn.bits & 0x1c1f) == 0x1019)
         {
-          #include "insns/srliw.h"
+          #include "insns/c_srai.h"
           break;
         }
-        if((insn.bits & 0x3f83ff) == 0x1029b)
+        if((insn.bits & 0x1c1f) == 0x419)
         {
-          #include "insns/sraiw.h"
+          #include "insns/c_slli32.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x1c:
+  case 0x3a:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      default:
-      {
+        if((insn.bits & 0x801f) == 0x1a)
+        {
+          #include "insns/c_add.h"
+          break;
+        }
+        if((insn.bits & 0x801f) == 0x801a)
+        {
+          #include "insns/c_sub.h"
+          break;
+        }
         throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x20:
-  {
-    #include "insns/c_li.h"
-    break;
-  }
-  case 0x21:
-  {
-    #include "insns/c_addi.h"
     break;
   }
-  case 0x22:
+  case 0x3b:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x1ffff) == 0x7bb)
         {
-          #include "insns/c_move.h"
+          #include "insns/remuw.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x6bb)
         {
-          #include "insns/c_j.h"
+          #include "insns/divuw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x1ffff) == 0x43b)
         {
-          #include "insns/c_move.h"
+          #include "insns/mulw.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x2bb)
         {
-          #include "insns/c_j.h"
+          #include "insns/srlw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x1ffff) == 0x3b)
         {
-          #include "insns/c_move.h"
+          #include "insns/addw.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x102bb)
         {
-          #include "insns/c_j.h"
+          #include "insns/sraw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x1ffff) == 0x1003b)
         {
-          #include "insns/c_move.h"
+          #include "insns/subw.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0xbb)
         {
-          #include "insns/c_j.h"
+          #include "insns/sllw.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x1ffff) == 0x73b)
         {
-          #include "insns/c_move.h"
+          #include "insns/remw.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x63b)
         {
-          #include "insns/c_j.h"
+          #include "insns/divw.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+    break;
+  }
+  case 0x3c:
+  {
+        if((insn.bits & 0x31f) == 0x1c)
         {
-          #include "insns/c_move.h"
+          #include "insns/c_add3.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x31f) == 0x21c)
         {
-          #include "insns/c_j.h"
+          #include "insns/c_or3.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x31f) == 0x31c)
         {
-          #include "insns/c_move.h"
+          #include "insns/c_and3.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x31f) == 0x11c)
         {
-          #include "insns/c_j.h"
+          #include "insns/c_sub3.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
+    break;
+  }
+  case 0x3d:
+  {
+    #include "insns/c_addiw.h"
+    break;
+  }
+  case 0x40:
+  {
+    #include "insns/c_li.h"
+    break;
+  }
+  case 0x41:
+  {
+    #include "insns/c_addi.h"
+    break;
+  }
+  case 0x42:
+  {
         if((insn.bits & 0x801f) == 0x2)
         {
           #include "insns/c_move.h"
@@ -1537,3045 +1209,410 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x23:
+  case 0x43:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/sb.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/sh.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/sw.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/sd.h"
-        break;
-      }
-      default:
-      {
+        if((insn.bits & 0x1ff) == 0x43)
+        {
+          #include "insns/fmadd_s.h"
+          break;
+        }
+        if((insn.bits & 0x1ff) == 0xc3)
+        {
+          #include "insns/fmadd_d.h"
+          break;
+        }
         throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x24:
+  case 0x44:
   {
     #include "insns/c_ldsp.h"
     break;
   }
-  case 0x25:
+  case 0x45:
   {
     #include "insns/c_lwsp.h"
     break;
   }
-  case 0x26:
+  case 0x46:
   {
     #include "insns/c_sdsp.h"
     break;
   }
-  case 0x27:
+  case 0x47:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x2:
-      {
-        #include "insns/fsw.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/fsd.h"
-        break;
-      }
-      default:
-      {
+        if((insn.bits & 0x1ff) == 0x47)
+        {
+          #include "insns/fmsub_s.h"
+          break;
+        }
+        if((insn.bits & 0x1ff) == 0xc7)
+        {
+          #include "insns/fmsub_d.h"
+          break;
+        }
         throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x28:
+  case 0x48:
   {
     #include "insns/c_swsp.h"
     break;
   }
-  case 0x29:
+  case 0x49:
   {
     #include "insns/c_ld.h"
     break;
   }
-  case 0x2a:
+  case 0x4a:
   {
     #include "insns/c_lw.h"
     break;
   }
-  case 0x2b:
+  case 0x4b:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x2:
-      {
-        if((insn.bits & 0x1ffff) == 0x192b)
-        {
-          #include "insns/amominu_w.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x92b)
+        if((insn.bits & 0x1ff) == 0x4b)
         {
-          #include "insns/amoand_w.h"
+          #include "insns/fnmsub_s.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x1d2b)
+        if((insn.bits & 0x1ff) == 0xcb)
         {
-          #include "insns/amomaxu_w.h"
+          #include "insns/fnmsub_d.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x152b)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x4c:
+  {
+    #include "insns/c_sd.h"
+    break;
+  }
+  case 0x4d:
+  {
+    #include "insns/c_sw.h"
+    break;
+  }
+  case 0x4f:
+  {
+        if((insn.bits & 0x1ff) == 0x4f)
         {
-          #include "insns/amomax_w.h"
+          #include "insns/fnmadd_s.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x12b)
+        if((insn.bits & 0x1ff) == 0xcf)
         {
-          #include "insns/amoadd_w.h"
+          #include "insns/fnmadd_d.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0xd2b)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x50:
+  {
+    #include "insns/c_beq.h"
+    break;
+  }
+  case 0x51:
+  {
+    #include "insns/c_bne.h"
+    break;
+  }
+  case 0x52:
+  {
+        if((insn.bits & 0x801f) == 0x12)
         {
-          #include "insns/amoor_w.h"
+          #include "insns/c_lw0.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x112b)
+        if((insn.bits & 0x801f) == 0x8012)
         {
-          #include "insns/amomin_w.h"
+          #include "insns/c_ld0.h"
           break;
         }
-        if((insn.bits & 0x1ffff) == 0x52b)
-        {
-          #include "insns/amoswap_w.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1ffff) == 0x19ab)
-        {
-          #include "insns/amominu_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x9ab)
-        {
-          #include "insns/amoand_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x1dab)
-        {
-          #include "insns/amomaxu_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x1ab)
-        {
-          #include "insns/amoadd_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x15ab)
-        {
-          #include "insns/amomax_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0xdab)
-        {
-          #include "insns/amoor_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x5ab)
-        {
-          #include "insns/amoswap_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x11ab)
-        {
-          #include "insns/amomin_d.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x2c:
-  {
-    #include "insns/c_sd.h"
-    break;
-  }
-  case 0x2d:
-  {
-    #include "insns/c_sw.h"
-    break;
-  }
-  case 0x2f:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x1:
-      {
-        #include "insns/fence_i.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/fence.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/fence_l_v.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/fence_g_v.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/fence_l_cv.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/fence_g_cv.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x30:
-  {
-    #include "insns/c_beq.h"
-    break;
-  }
-  case 0x31:
-  {
-    #include "insns/c_bne.h"
-    break;
-  }
-  case 0x32:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x33:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1ffff) == 0x33)
-        {
-          #include "insns/add.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x433)
-        {
-          #include "insns/mul.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x10033)
-        {
-          #include "insns/sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1ffff) == 0xb3)
-        {
-          #include "insns/sll.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x4b3)
-        {
-          #include "insns/mulh.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x1ffff) == 0x533)
-        {
-          #include "insns/mulhsu.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x133)
-        {
-          #include "insns/slt.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1ffff) == 0x1b3)
-        {
-          #include "insns/sltu.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x5b3)
-        {
-          #include "insns/mulhu.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1ffff) == 0x633)
-        {
-          #include "insns/div.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x233)
-        {
-          #include "insns/xor.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1ffff) == 0x102b3)
-        {
-          #include "insns/sra.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x2b3)
-        {
-          #include "insns/srl.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x6b3)
-        {
-          #include "insns/divu.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1ffff) == 0x733)
-        {
-          #include "insns/rem.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x333)
-        {
-          #include "insns/or.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x1ffff) == 0x7b3)
-        {
-          #include "insns/remu.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x3b3)
-        {
-          #include "insns/and.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x34:
-  {
-    #include "insns/c_flw.h"
-    break;
-  }
-  case 0x35:
-  {
-    #include "insns/c_fld.h"
-    break;
-  }
-  case 0x36:
-  {
-    #include "insns/c_fsw.h"
-    break;
-  }
-  case 0x37:
-  {
-    #include "insns/lui.h"
-    break;
-  }
-  case 0x38:
-  {
-    #include "insns/c_fsd.h"
-    break;
-  }
-  case 0x39:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x3a:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x3b:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1ffff) == 0x43b)
-        {
-          #include "insns/mulw.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x3b)
-        {
-          #include "insns/addw.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x1003b)
-        {
-          #include "insns/subw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1ffff) == 0xbb)
-        {
-          #include "insns/sllw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1ffff) == 0x63b)
-        {
-          #include "insns/divw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1ffff) == 0x6bb)
-        {
-          #include "insns/divuw.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x2bb)
-        {
-          #include "insns/srlw.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x102bb)
-        {
-          #include "insns/sraw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1ffff) == 0x73b)
-        {
-          #include "insns/remw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x1ffff) == 0x7bb)
-        {
-          #include "insns/remuw.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x3c:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x40:
-  {
-    #include "insns/c_li.h"
-    break;
-  }
-  case 0x41:
-  {
-    #include "insns/c_addi.h"
-    break;
-  }
-  case 0x42:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x43:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/fmadd_s.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/fmadd_d.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/fmadd_s.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/fmadd_d.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x44:
-  {
-    #include "insns/c_ldsp.h"
-    break;
-  }
-  case 0x45:
-  {
-    #include "insns/c_lwsp.h"
-    break;
-  }
-  case 0x46:
-  {
-    #include "insns/c_sdsp.h"
-    break;
-  }
-  case 0x47:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/fmsub_s.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/fmsub_d.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/fmsub_s.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/fmsub_d.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x48:
-  {
-    #include "insns/c_swsp.h"
-    break;
-  }
-  case 0x49:
-  {
-    #include "insns/c_ld.h"
-    break;
-  }
-  case 0x4a:
-  {
-    #include "insns/c_lw.h"
-    break;
-  }
-  case 0x4b:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/fnmsub_s.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/fnmsub_d.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/fnmsub_s.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/fnmsub_d.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x4c:
-  {
-    #include "insns/c_sd.h"
-    break;
-  }
-  case 0x4d:
-  {
-    #include "insns/c_sw.h"
-    break;
-  }
-  case 0x4f:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/fnmadd_s.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/fnmadd_d.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/fnmadd_s.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/fnmadd_d.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x50:
-  {
-    #include "insns/c_beq.h"
-    break;
-  }
-  case 0x51:
-  {
-    #include "insns/c_bne.h"
-    break;
-  }
-  case 0x52:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x12)
-        {
-          #include "insns/c_lw0.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8012)
-        {
-          #include "insns/c_ld0.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x53:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x3ff1ff) == 0x9053)
-        {
-          #include "insns/fcvt_lu_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x18053)
-        {
-          #include "insns/fmin_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x11053)
-        {
-          #include "insns/fcvt_s_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xe053)
-        {
-          #include "insns/fcvt_s_w.h"
-          break;
-        }
-        if((insn.bits & 0x7c1ffff) == 0x1c053)
-        {
-          #include "insns/mftx_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x8053)
-        {
-          #include "insns/fcvt_l_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x17053)
-        {
-          #include "insns/fle_s.h"
-          break;
-        }
-        if((insn.bits & 0x7ffffff) == 0x1d053)
-        {
-          #include "insns/mffsr.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x3053)
-        {
-          #include "insns/fdiv_s.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0x1f053)
-        {
-          #include "insns/mtfsr.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xd053)
-        {
-          #include "insns/fcvt_s_lu.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x2053)
-        {
-          #include "insns/fmul_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x16053)
-        {
-          #include "insns/flt_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x15053)
-        {
-          #include "insns/feq_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x7053)
-        {
-          #include "insns/fsgnjx_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x19053)
-        {
-          #include "insns/fmax_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xb053)
-        {
-          #include "insns/fcvt_wu_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xa053)
-        {
-          #include "insns/fcvt_w_s.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0x1e053)
-        {
-          #include "insns/mxtf_s.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x1053)
-        {
-          #include "insns/fsub_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x5053)
-        {
-          #include "insns/fsgnj_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xf053)
-        {
-          #include "insns/fcvt_s_wu.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xc053)
-        {
-          #include "insns/fcvt_s_l.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x4053)
-        {
-          #include "insns/fsqrt_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x6053)
-        {
-          #include "insns/fsgnjn_s.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x53)
-        {
-          #include "insns/fadd_s.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1ffff) == 0x180d3)
-        {
-          #include "insns/fmin_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xc0d3)
-        {
-          #include "insns/fcvt_d_l.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0xe0d3)
-        {
-          #include "insns/fcvt_d_w.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0x100d3)
-        {
-          #include "insns/fcvt_d_s.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x190d3)
-        {
-          #include "insns/fmax_d.h"
-          break;
-        }
-        if((insn.bits & 0x7c1ffff) == 0x1c0d3)
-        {
-          #include "insns/mftx_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x170d3)
-        {
-          #include "insns/fle_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x160d3)
-        {
-          #include "insns/flt_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x20d3)
-        {
-          #include "insns/fmul_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x70d3)
-        {
-          #include "insns/fsgnjx_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x150d3)
-        {
-          #include "insns/feq_d.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0xf0d3)
-        {
-          #include "insns/fcvt_d_wu.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xb0d3)
-        {
-          #include "insns/fcvt_wu_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x60d3)
-        {
-          #include "insns/fsgnjn_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xd0d3)
-        {
-          #include "insns/fcvt_d_lu.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xa0d3)
-        {
-          #include "insns/fcvt_w_d.h"
-          break;
-        }
-        if((insn.bits & 0x3fffff) == 0x1e0d3)
-        {
-          #include "insns/mxtf_d.h"
-          break;
-        }
-        if((insn.bits & 0x1ffff) == 0x50d3)
-        {
-          #include "insns/fsgnj_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x80d3)
-        {
-          #include "insns/fcvt_l_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0xd3)
-        {
-          #include "insns/fadd_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x90d3)
-        {
-          #include "insns/fcvt_lu_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x10d3)
-        {
-          #include "insns/fsub_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x40d3)
-        {
-          #include "insns/fsqrt_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x30d3)
-        {
-          #include "insns/fdiv_d.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x3ff1ff) == 0x9053)
-        {
-          #include "insns/fcvt_lu_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x11053)
-        {
-          #include "insns/fcvt_s_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xe053)
-        {
-          #include "insns/fcvt_s_w.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x8053)
-        {
-          #include "insns/fcvt_l_s.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x3053)
-        {
-          #include "insns/fdiv_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xd053)
-        {
-          #include "insns/fcvt_s_lu.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x2053)
-        {
-          #include "insns/fmul_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xb053)
-        {
-          #include "insns/fcvt_wu_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xa053)
-        {
-          #include "insns/fcvt_w_s.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x1053)
-        {
-          #include "insns/fsub_s.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xf053)
-        {
-          #include "insns/fcvt_s_wu.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xc053)
-        {
-          #include "insns/fcvt_s_l.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x4053)
-        {
-          #include "insns/fsqrt_s.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x53)
-        {
-          #include "insns/fadd_s.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x3ff1ff) == 0xc0d3)
-        {
-          #include "insns/fcvt_d_l.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x20d3)
-        {
-          #include "insns/fmul_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xb0d3)
-        {
-          #include "insns/fcvt_wu_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xd0d3)
-        {
-          #include "insns/fcvt_d_lu.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0xa0d3)
-        {
-          #include "insns/fcvt_w_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x80d3)
-        {
-          #include "insns/fcvt_l_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0xd3)
-        {
-          #include "insns/fadd_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x90d3)
-        {
-          #include "insns/fcvt_lu_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x10d3)
-        {
-          #include "insns/fsub_d.h"
-          break;
-        }
-        if((insn.bits & 0x3ff1ff) == 0x40d3)
-        {
-          #include "insns/fsqrt_d.h"
-          break;
-        }
-        if((insn.bits & 0x1f1ff) == 0x30d3)
-        {
-          #include "insns/fdiv_d.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x54:
-  {
-    #include "insns/c_flw.h"
-    break;
-  }
-  case 0x55:
-  {
-    #include "insns/c_fld.h"
-    break;
-  }
-  case 0x56:
-  {
-    #include "insns/c_fsw.h"
-    break;
-  }
-  case 0x58:
-  {
-    #include "insns/c_fsd.h"
-    break;
-  }
-  case 0x59:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
-        {
-          #include "insns/c_srli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1419)
-        {
-          #include "insns/c_srai32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0xc19)
-        {
-          #include "insns/c_srli32.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1819)
-        {
-          #include "insns/c_slliw.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x1019)
-        {
-          #include "insns/c_srai.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x419)
-        {
-          #include "insns/c_slli32.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x5a:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x5c:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      default:
-      {
         throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x60:
-  {
-    #include "insns/c_li.h"
     break;
   }
-  case 0x61:
-  {
-    #include "insns/c_addi.h"
-    break;
-  }
-  case 0x62:
+  case 0x53:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
-        {
-          #include "insns/c_j.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x2)
-        {
-          #include "insns/c_move.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x180d3)
         {
-          #include "insns/c_j.h"
+          #include "insns/fmin_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff1ff) == 0x9053)
         {
-          #include "insns/c_move.h"
+          #include "insns/fcvt_lu_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x18053)
         {
-          #include "insns/c_j.h"
+          #include "insns/fmin_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff1ff) == 0xc0d3)
         {
-          #include "insns/c_move.h"
+          #include "insns/fcvt_d_l.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x3fffff) == 0xe0d3)
         {
-          #include "insns/c_j.h"
+          #include "insns/fcvt_d_w.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3fffff) == 0x100d3)
         {
-          #include "insns/c_move.h"
+          #include "insns/fcvt_d_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x190d3)
         {
-          #include "insns/c_j.h"
+          #include "insns/fmax_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff1ff) == 0x11053)
         {
-          #include "insns/c_move.h"
+          #include "insns/fcvt_s_d.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x3ff1ff) == 0xe053)
         {
-          #include "insns/c_j.h"
+          #include "insns/fcvt_s_w.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x7c1ffff) == 0x1c0d3)
         {
-          #include "insns/c_move.h"
+          #include "insns/mftx_d.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x7c1ffff) == 0x1c053)
         {
-          #include "insns/c_j.h"
+          #include "insns/mftx_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x2)
+        if((insn.bits & 0x3ff1ff) == 0x8053)
         {
-          #include "insns/c_move.h"
+          #include "insns/fcvt_l_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8002)
+        if((insn.bits & 0x1ffff) == 0x17053)
         {
-          #include "insns/c_j.h"
+          #include "insns/fle_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x63:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/beq.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/bne.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/blt.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/bge.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/bltu.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/bgeu.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x64:
-  {
-    #include "insns/c_ldsp.h"
-    break;
-  }
-  case 0x65:
-  {
-    #include "insns/c_lwsp.h"
-    break;
-  }
-  case 0x66:
-  {
-    #include "insns/c_sdsp.h"
-    break;
-  }
-  case 0x67:
-  {
-    #include "insns/j.h"
-    break;
-  }
-  case 0x68:
-  {
-    #include "insns/c_swsp.h"
-    break;
-  }
-  case 0x69:
-  {
-    #include "insns/c_ld.h"
-    break;
-  }
-  case 0x6a:
-  {
-    #include "insns/c_lw.h"
-    break;
-  }
-  case 0x6b:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/jalr_c.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/jalr_r.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/jalr_j.h"
-        break;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x7ffffff) == 0x26b)
+        if((insn.bits & 0x7ffffff) == 0x1d053)
         {
-          #include "insns/rdnpc.h"
+          #include "insns/mffsr.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x6c:
-  {
-    #include "insns/c_sd.h"
-    break;
-  }
-  case 0x6d:
-  {
-    #include "insns/c_sw.h"
-    break;
-  }
-  case 0x6f:
-  {
-    #include "insns/jal.h"
-    break;
-  }
-  case 0x70:
-  {
-    #include "insns/c_beq.h"
-    break;
-  }
-  case 0x71:
-  {
-    #include "insns/c_bne.h"
-    break;
-  }
-  case 0x72:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1f1ff) == 0x3053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fdiv_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x1ffff) == 0x170d3)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/fle_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x3fffff) == 0x1f053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/mtfsr.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3ff1ff) == 0xd053)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/fcvt_s_lu.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1f1ff) == 0x2053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fmul_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x1ffff) == 0x160d3)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/flt_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1f1ff) == 0x20d3)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fmul_d.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x1ffff) == 0x16053)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/flt_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1ffff) == 0x15053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/feq_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x1ffff) == 0x70d3)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/fsgnjx_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1ffff) == 0x7053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fsgnjx_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x1ffff) == 0x150d3)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/feq_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x3fffff) == 0xf0d3)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fcvt_d_wu.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3ff1ff) == 0xb0d3)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/fcvt_wu_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x12)
+        if((insn.bits & 0x1ffff) == 0x19053)
         {
-          #include "insns/c_lw0.h"
+          #include "insns/fmax_s.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x8012)
+        if((insn.bits & 0x3ff1ff) == 0xb053)
         {
-          #include "insns/c_ld0.h"
+          #include "insns/fcvt_wu_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x73:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/vcfgivl.h"
-        break;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x3fffff) == 0xf3)
+        if((insn.bits & 0x1ffff) == 0x60d3)
         {
-          #include "insns/setvl.h"
+          #include "insns/fsgnjn_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0xf80003ff) == 0x173)
+        if((insn.bits & 0x3ff1ff) == 0xa053)
         {
-          #include "insns/vf.h"
+          #include "insns/fcvt_w_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x74:
-  {
-    #include "insns/c_flw.h"
-    break;
-  }
-  case 0x75:
-  {
-    #include "insns/c_fld.h"
-    break;
-  }
-  case 0x76:
-  {
-    #include "insns/c_fsw.h"
-    break;
-  }
-  case 0x77:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0xffffffff) == 0x77)
+        if((insn.bits & 0x3ff1ff) == 0xd0d3)
         {
-          #include "insns/syscall.h"
+          #include "insns/fcvt_d_lu.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0xffffffff) == 0xf7)
+        if((insn.bits & 0x3ff1ff) == 0xa0d3)
         {
-          #include "insns/break.h"
+          #include "insns/fcvt_w_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0xffffffff) == 0x177)
+        if((insn.bits & 0x3fffff) == 0x1e0d3)
         {
-          #include "insns/stop.h"
+          #include "insns/mxtf_d.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x7ffffff) == 0x1f7)
+        if((insn.bits & 0x3fffff) == 0x1e053)
         {
-          #include "insns/utidx.h"
+          #include "insns/mxtf_s.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
-    break;
-  }
-  case 0x78:
-  {
-    #include "insns/c_fsd.h"
-    break;
-  }
-  case 0x79:
-  {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x1f1ff) == 0x1053)
         {
-          #include "insns/c_slli.h"
+          #include "insns/fsub_s.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x1ffff) == 0x5053)
         {
-          #include "insns/c_srli.h"
+          #include "insns/fsgnj_s.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x1ffff) == 0x50d3)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/fsgnj_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x3ff1ff) == 0x80d3)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/fcvt_l_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x1f1ff) == 0xd3)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/fadd_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x3ff1ff) == 0xf053)
         {
-          #include "insns/c_srai.h"
+          #include "insns/fcvt_s_wu.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x3ff1ff) == 0xc053)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/fcvt_s_l.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x3ff1ff) == 0x90d3)
         {
-          #include "insns/c_slli.h"
+          #include "insns/fcvt_lu_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x1f1ff) == 0x10d3)
         {
-          #include "insns/c_srli.h"
+          #include "insns/fsub_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x3ff1ff) == 0x4053)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/fsqrt_s.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x1ffff) == 0x6053)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/fsgnjn_s.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x3ff1ff) == 0x40d3)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/fsqrt_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x1f1ff) == 0x30d3)
         {
-          #include "insns/c_srai.h"
+          #include "insns/fdiv_d.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x1f1ff) == 0x53)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/fadd_s.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
+    break;
+  }
+  case 0x54:
+  {
+    #include "insns/c_flw.h"
+    break;
+  }
+  case 0x55:
+  {
+    #include "insns/c_fld.h"
+    break;
+  }
+  case 0x56:
+  {
+    #include "insns/c_fsw.h"
+    break;
+  }
+  case 0x58:
+  {
+    #include "insns/c_fsd.h"
+    break;
+  }
+  case 0x59:
+  {
         if((insn.bits & 0x1c1f) == 0x19)
         {
           #include "insns/c_slli.h"
@@ -4612,165 +1649,280 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
-        {
-          #include "insns/c_slli.h"
-          break;
-        }
-        if((insn.bits & 0x1c1f) == 0x819)
+    break;
+  }
+  case 0x5a:
+  {
+        if((insn.bits & 0x801f) == 0x1a)
         {
-          #include "insns/c_srli.h"
+          #include "insns/c_add.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x801f) == 0x801a)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/c_sub.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x5c:
+  {
+        if((insn.bits & 0x31f) == 0x1c)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/c_add3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x31f) == 0x21c)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/c_or3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x31f) == 0x31c)
         {
-          #include "insns/c_srai.h"
+          #include "insns/c_and3.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x31f) == 0x11c)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/c_sub3.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+    break;
+  }
+  case 0x5d:
+  {
+    #include "insns/c_addiw.h"
+    break;
+  }
+  case 0x60:
+  {
+    #include "insns/c_li.h"
+    break;
+  }
+  case 0x61:
+  {
+    #include "insns/c_addi.h"
+    break;
+  }
+  case 0x62:
+  {
+        if((insn.bits & 0x801f) == 0x2)
         {
-          #include "insns/c_slli.h"
+          #include "insns/c_move.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0x801f) == 0x8002)
         {
-          #include "insns/c_srli.h"
+          #include "insns/c_j.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x63:
+  {
+        if((insn.bits & 0x3ff) == 0x363)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/bltu.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x3ff) == 0xe3)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/bne.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x3ff) == 0x3e3)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/bgeu.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x3ff) == 0x263)
         {
-          #include "insns/c_srai.h"
+          #include "insns/blt.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x3ff) == 0x2e3)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/bge.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+        if((insn.bits & 0x3ff) == 0x63)
         {
-          #include "insns/c_slli.h"
+          #include "insns/beq.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x64:
+  {
+    #include "insns/c_ldsp.h"
+    break;
+  }
+  case 0x65:
+  {
+    #include "insns/c_lwsp.h"
+    break;
+  }
+  case 0x66:
+  {
+    #include "insns/c_sdsp.h"
+    break;
+  }
+  case 0x67:
+  {
+    #include "insns/j.h"
+    break;
+  }
+  case 0x68:
+  {
+    #include "insns/c_swsp.h"
+    break;
+  }
+  case 0x69:
+  {
+    #include "insns/c_ld.h"
+    break;
+  }
+  case 0x6a:
+  {
+    #include "insns/c_lw.h"
+    break;
+  }
+  case 0x6b:
+  {
+        if((insn.bits & 0x3ff) == 0x6b)
         {
-          #include "insns/c_srli.h"
+          #include "insns/jalr_c.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x3ff) == 0x16b)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/jalr_j.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        if((insn.bits & 0x3ff) == 0xeb)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/jalr_r.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0x7ffffff) == 0x26b)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/rdnpc.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x6c:
+  {
+    #include "insns/c_sd.h"
+    break;
+  }
+  case 0x6d:
+  {
+    #include "insns/c_sw.h"
+    break;
+  }
+  case 0x6f:
+  {
+    #include "insns/jal.h"
+    break;
+  }
+  case 0x70:
+  {
+    #include "insns/c_beq.h"
+    break;
+  }
+  case 0x71:
+  {
+    #include "insns/c_bne.h"
+    break;
+  }
+  case 0x72:
+  {
+        if((insn.bits & 0x801f) == 0x12)
         {
-          #include "insns/c_srai.h"
+          #include "insns/c_lw0.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0x801f) == 0x8012)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/c_ld0.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x1c1f) == 0x19)
+    break;
+  }
+  case 0x73:
+  {
+        if((insn.bits & 0x3ff) == 0x73)
         {
-          #include "insns/c_slli.h"
+          #include "insns/vcfgivl.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x819)
+        if((insn.bits & 0xf80003ff) == 0x173)
         {
-          #include "insns/c_srli.h"
+          #include "insns/vf.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1419)
+        if((insn.bits & 0x3fffff) == 0xf3)
         {
-          #include "insns/c_srai32.h"
+          #include "insns/setvl.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0xc19)
+        throw trap_illegal_instruction;
+    break;
+  }
+  case 0x74:
+  {
+    #include "insns/c_flw.h"
+    break;
+  }
+  case 0x75:
+  {
+    #include "insns/c_fld.h"
+    break;
+  }
+  case 0x76:
+  {
+    #include "insns/c_fsw.h"
+    break;
+  }
+  case 0x77:
+  {
+        if((insn.bits & 0xffffffff) == 0x177)
         {
-          #include "insns/c_srli32.h"
+          #include "insns/stop.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1819)
+        if((insn.bits & 0xffffffff) == 0xf7)
         {
-          #include "insns/c_slliw.h"
+          #include "insns/break.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x1019)
+        if((insn.bits & 0x7ffffff) == 0x1f7)
         {
-          #include "insns/c_srai.h"
+          #include "insns/utidx.h"
           break;
         }
-        if((insn.bits & 0x1c1f) == 0x419)
+        if((insn.bits & 0xffffffff) == 0x77)
         {
-          #include "insns/c_slli32.h"
+          #include "insns/syscall.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
+    break;
+  }
+  case 0x78:
+  {
+    #include "insns/c_fsd.h"
+    break;
+  }
+  case 0x79:
+  {
         if((insn.bits & 0x1c1f) == 0x19)
         {
           #include "insns/c_slli.h"
@@ -4807,76 +1959,10 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
   case 0x7a:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
-        {
-          #include "insns/c_add.h"
-          break;
-        }
-        if((insn.bits & 0x801f) == 0x801a)
-        {
-          #include "insns/c_sub.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
         if((insn.bits & 0x801f) == 0x1a)
         {
           #include "insns/c_add.h"
@@ -4888,170 +1974,71 @@ switch((insn.bits >> 0x0) & 0x7f)
           break;
         }
         throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+    break;
+  }
+  case 0x7b:
+  {
+        if((insn.bits & 0x7c1ffff) == 0x17b)
         {
-          #include "insns/c_add.h"
+          #include "insns/mfpcr.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0xf801ffff) == 0x1fb)
         {
-          #include "insns/c_sub.h"
+          #include "insns/mtpcr.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x6:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x7ffffff) == 0xfb)
         {
-          #include "insns/c_add.h"
+          #include "insns/di.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0xffffffff) == 0x2fb)
         {
-          #include "insns/c_sub.h"
+          #include "insns/cflush.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x7:
-      {
-        if((insn.bits & 0x801f) == 0x1a)
+        if((insn.bits & 0x7ffffff) == 0x7b)
         {
-          #include "insns/c_add.h"
+          #include "insns/ei.h"
           break;
         }
-        if((insn.bits & 0x801f) == 0x801a)
+        if((insn.bits & 0xffffffff) == 0x27b)
         {
-          #include "insns/c_sub.h"
+          #include "insns/eret.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x7b:
+  case 0x7c:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        if((insn.bits & 0x7ffffff) == 0x7b)
-        {
-          #include "insns/ei.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x1:
-      {
-        if((insn.bits & 0x7ffffff) == 0xfb)
-        {
-          #include "insns/di.h"
-          break;
-        }
-        throw trap_illegal_instruction;
-      }
-      case 0x2:
-      {
-        if((insn.bits & 0x7c1ffff) == 0x17b)
+        if((insn.bits & 0x31f) == 0x1c)
         {
-          #include "insns/mfpcr.h"
+          #include "insns/c_add3.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x3:
-      {
-        if((insn.bits & 0xf801ffff) == 0x1fb)
+        if((insn.bits & 0x31f) == 0x21c)
         {
-          #include "insns/mtpcr.h"
+          #include "insns/c_or3.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x4:
-      {
-        if((insn.bits & 0xffffffff) == 0x27b)
+        if((insn.bits & 0x31f) == 0x31c)
         {
-          #include "insns/eret.h"
+          #include "insns/c_and3.h"
           break;
         }
-        throw trap_illegal_instruction;
-      }
-      case 0x5:
-      {
-        if((insn.bits & 0xffffffff) == 0x2fb)
+        if((insn.bits & 0x31f) == 0x11c)
         {
-          #include "insns/cflush.h"
+          #include "insns/c_sub3.h"
           break;
         }
         throw trap_illegal_instruction;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
     break;
   }
-  case 0x7c:
+  case 0x7d:
   {
-    switch((insn.bits >> 0x7) & 0x7)
-    {
-      case 0x0:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x1:
-      {
-        #include "insns/c_add3.h"
-        break;
-      }
-      case 0x2:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x3:
-      {
-        #include "insns/c_sub3.h"
-        break;
-      }
-      case 0x4:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x5:
-      {
-        #include "insns/c_or3.h"
-        break;
-      }
-      case 0x6:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      case 0x7:
-      {
-        #include "insns/c_and3.h"
-        break;
-      }
-      default:
-      {
-        throw trap_illegal_instruction;
-      }
-    }
+    #include "insns/c_addiw.h"
     break;
   }
   default:
diff --git a/riscv/insns/c_addiw.h b/riscv/insns/c_addiw.h
new file mode 100644
index 0000000..6a1e0a3
--- /dev/null
+++ b/riscv/insns/c_addiw.h
@@ -0,0 +1,3 @@
+require_rvc;
+require_xpr64;
+CRD = sext32(CRS2 + CIMM6);
-- 
2.30.2